{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "注意DDPG中critic网络的输入是state加上action。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim, hidden_dim = 256, init_w=3e-3):\n",
    "        super(Actor, self).__init__()  \n",
    "        self.linear1 = nn.Linear(state_dim, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, action_dim)\n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = torch.tanh(self.linear3(x))\n",
    "        return x\n",
    "        \n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim, hidden_dim=256, init_w=3e-3):\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.linear1 = nn.Linear(state_dim + action_dim, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "        # 随机初始化为较小的值\n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state, action):\n",
    "        # 按维数1拼接\n",
    "        x = torch.cat([state, action], 1)\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        '''_summary_\n",
    "        Args:\n",
    "            trainsitions (tuple): _description_\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer):\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # sequential sampling\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else:\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "class Policy(object):\n",
    "\tdef __init__(self,cfg):\n",
    "\t\tself.gamma = cfg.gamma # 奖励的折扣因子\n",
    "\t\tself.actor_lr = cfg.actor_lr # actor学习率\n",
    "\t\tself.critic_lr = cfg.critic_lr # critic学习率\n",
    "\t\tself.policy_noise = cfg.policy_noise\n",
    "\t\tself.noise_clip = cfg.noise_clip\n",
    "\t\tself.expl_noise = cfg.expl_noise\n",
    "\t\tself.policy_freq = cfg.policy_freq\n",
    "\t\tself.batch_size =  cfg.batch_size \n",
    "\t\tself.tau = cfg.tau\n",
    "\t\tself.sample_count = 0\n",
    "\t\tself.update_count = 0\n",
    "\t\tself.policy_freq = cfg.policy_freq\n",
    "\t\tself.explore_steps = cfg.explore_steps\n",
    "\t\tself.action_dim = cfg.action_dim\n",
    "\t\tself.action_space = cfg.action_space\n",
    "\t\tself.action_high = cfg.action_space.high[0]\n",
    "\t\tself.action_low = cfg.action_space.low[0]\n",
    "\t\tself.action_scale = (self.action_high - self.action_low) / 2\n",
    "\t\tself.action_bias = (self.action_high + self.action_low) / 2\n",
    "\t\tself.device = torch.device(cfg.device)\n",
    "\t\t\n",
    "\t\tself.actor = Actor(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.actor_hidden_dim).to(self.device)\n",
    "\t\tself.actor_target = Actor(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.actor_hidden_dim).to(self.device)\n",
    "\t\tself.critic_1 = Critic(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.critic_hidden_dim).to(self.device)\n",
    "\t\tself.critic_2 = Critic(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.critic_hidden_dim).to(self.device)\n",
    "\t\tself.critic_1_target = Critic(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.critic_hidden_dim).to(self.device)\n",
    "\t\tself.critic_2_target = Critic(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.critic_hidden_dim).to(self.device)\n",
    "\t\t# 复制参数到目标网络\n",
    "\t\tself.actor_target.load_state_dict(self.actor.state_dict()) \n",
    "\t\tself.critic_1_target.load_state_dict(self.critic_1.state_dict())\n",
    "\t\tself.critic_2_target.load_state_dict(self.critic_2.state_dict())\n",
    "\t\t\n",
    "\t\tself.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr = self.actor_lr)\n",
    "\t\tself.critic_1_optimizer = torch.optim.Adam(self.critic_1.parameters(), lr = self.critic_lr)\n",
    "\t\tself.critic_2_optimizer = torch.optim.Adam(self.critic_2.parameters(), lr = self.critic_lr)\n",
    "\t\tself.memory = ReplayBuffer(cfg.buffer_size)\n",
    "\t\t# self.memory = ReplayBuffer(state_dim, action_dim)\n",
    "\n",
    "\tdef sample_action(self, state):\n",
    "\t\t''' 采样动作\n",
    "\t\t'''\n",
    "\t\tself.sample_count += 1\n",
    "\t\tif self.sample_count < self.explore_steps:\n",
    "\t\t\treturn self.action_space.sample()\n",
    "\t\telse:\n",
    "\t\t\tstate = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "\t\t\taction = self.actor(state)\n",
    "\t\t\taction = self.action_scale * action + self.action_bias\n",
    "\t\t\taction = action.detach().cpu().numpy()[0]\n",
    "\t\t\taction_noise = np.random.normal(0, self.action_scale * self.expl_noise, size=self.action_dim)\n",
    "\t\t\taction = (action + action_noise).clip(self.action_space.low, self.action_space.high)\n",
    "\t\t\treturn action\n",
    "\n",
    "\t@torch.no_grad()\n",
    "\tdef predict_action(self, state):\n",
    "\t\t''' 预测动作\n",
    "\t\t'''\n",
    "\t\tstate = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "\t\taction = self.actor(state)\n",
    "\t\taction = self.action_scale * action + self.action_bias # 对actor计算的动作分布放缩\n",
    "\t\treturn action.detach().cpu().numpy()[0]\n",
    "\n",
    "\tdef update(self):\n",
    "\t\t# if len(self.memory) < self.batch_size:\n",
    "\t\t# \treturn\n",
    "\t\tif len(self.memory) < self.explore_steps: # 当经验回放中不满足一个批量时，不更新策略\n",
    "\t\t\treturn\n",
    "\t\tstate, action, reward, next_state, done = self.memory.sample(self.batch_size) # 从经验回放中随机采样一个批量的转移(transition)\n",
    "         # 将数据转换为tensor\n",
    "\t\tstate = torch.tensor(np.array(state), device=self.device, dtype=torch.float32)\n",
    "\t\taction = torch.tensor(np.array(action), device=self.device, dtype=torch.float32)\n",
    "\t\tnext_state = torch.tensor(np.array(next_state), device=self.device, dtype=torch.float32)\n",
    "\t\treward = torch.tensor(reward, device=self.device, dtype=torch.float32).unsqueeze(1)\n",
    "\t\tdone = torch.tensor(done, device=self.device, dtype=torch.float32).unsqueeze(1)\n",
    "\t\t# update critic\n",
    "\t\t# noise = (torch.randn_like(action) * self.policy_noise).clamp(-self.noise_clip, self.noise_clip) # 构造加入目标动作的噪声\n",
    "        # 计算加入了噪声的目标动作\n",
    "\t\tnext_action = self.actor_target(next_state)\n",
    "\t\t# next_action = (self.actor_target(next_state) + noise).clamp(-self.action_scale+self.action_bias, self.action_scale+self.action_bias)\n",
    "        # 计算两个critic网络对t+1时刻的状态动作对的评分，并选取更小值来计算目标q值\n",
    "\t\ttarget_q1, target_q2 = self.critic_1_target(next_state, next_action).detach(), self.critic_2_target(next_state, next_action).detach()\n",
    "\t\ttarget_q = torch.min(target_q1, target_q2)\n",
    "\t\ttarget_q = reward + self.gamma * target_q * (1 - done)\n",
    "        # 计算两个critic网络对t时刻的状态动作对的评分\n",
    "\t\tcurrent_q1, current_q2 = self.critic_1(state, action), self.critic_2(state, action)\n",
    "        # 计算均方根损失\n",
    "\t\tcritic_1_loss = F.mse_loss(current_q1, target_q)\n",
    "\t\tcritic_2_loss = F.mse_loss(current_q2, target_q)\n",
    "\t\tself.critic_1_optimizer.zero_grad()\n",
    "\t\tcritic_1_loss.backward()\n",
    "\t\tself.critic_1_optimizer.step()\n",
    "\t\tself.critic_2_optimizer.zero_grad()\n",
    "\t\tcritic_2_loss.backward()\n",
    "\t\tself.critic_2_optimizer.step()\n",
    "\t\tfor param, target_param in zip(self.critic_1.parameters(), self.critic_1_target.parameters()):\n",
    "\t\t\ttarget_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)\n",
    "\t\tfor param, target_param in zip(self.critic_2.parameters(), self.critic_2_target.parameters()):\n",
    "\t\t\ttarget_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)\n",
    "\t\tif self.update_count % self.policy_freq == 0:\n",
    "            # 延迟策略更新，actor的更新频率低于critic\n",
    "\t\t\tactor_loss = -self.critic_1(state, self.actor(state)).mean()\n",
    "\t\t\tself.actor_optimizer.zero_grad()\n",
    "\t\t\tactor_loss.backward()\n",
    "\t\t\tself.actor_optimizer.step()\n",
    "            #目标网络软更新\n",
    "\t\t\tfor param, target_param in zip(self.actor.parameters(), self.actor_target.parameters()):\n",
    "\t\t\t\ttarget_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)\n",
    "\t\tself.update_count += 1\n",
    "\t\t\t\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "def train(cfg):\n",
    "    env = gym.make(cfg.env_id)\n",
    "    setattr(cfg, \"action_space\", env.action_space)\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "    setattr(cfg, \"action_dim\", env.action_space.shape[0])\n",
    "    policy = Policy(cfg)\n",
    "    rewards,frames = [],[]\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        state, _ = env.reset()\n",
    "        ep_reward = 0\n",
    "        for i_step in range(cfg.max_steps):\n",
    "            action = policy.sample_action(state)\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, truncated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward\n",
    "            policy.memory.push((state, action, reward, next_state, truncated))\n",
    "            policy.update()\n",
    "            state = next_state\n",
    "            if truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        if (i_ep+1)%10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = 'TD3' # 算法名称\n",
    "        self.env_id = 'Pendulum-v1' # 环境名称\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子\n",
    "        self.train_eps = 100 # 训练迭代次数\n",
    "        self.test_eps = 20 # 测试迭代次数\n",
    "        self.eval_eps = 10 # 评估迭代次数\n",
    "        self.eval_per_episode = 5 # 每隔几代评估\n",
    "        self.explore_steps = 100 # 探索步数\n",
    "        self.max_steps = 200 # 每次迭代最大时间步\n",
    "        self.policy_freq = 2  # 策略网络更新频率\n",
    "        self.actor_lr = 1e-3 \n",
    "        self.critic_lr = 1e-3 \n",
    "        self.actor_hidden_dim = 256 # actor网络隐藏层维度\n",
    "        self.critic_hidden_dim = 256 # critic网络隐藏层维度\n",
    "        self.gamma = 0.99 \n",
    "        self.tau = 0.005 # 目标网络软更新系数\n",
    "        self.policy_noise = 0.2 # 加入策略网络的噪声\n",
    "        self.expl_noise = 0.1 # 高斯噪声标准差\n",
    "        self.noise_clip = 0.5 # 加入策略网络噪声范围\n",
    "        self.batch_size = 100 # 训练批次大小\n",
    "        self.buffer_size = 8000 # 经验回放池大小\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda' # 训练设备"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t        TD3         \t   <class 'str'>    \n",
      "       env_id       \t    Pendulum-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "     train_eps      \t        100         \t   <class 'int'>    \n",
      "      test_eps      \t         20         \t   <class 'int'>    \n",
      "      eval_eps      \t         10         \t   <class 'int'>    \n",
      "  eval_per_episode  \t         5          \t   <class 'int'>    \n",
      "   explore_steps    \t        100         \t   <class 'int'>    \n",
      "     max_steps      \t        200         \t   <class 'int'>    \n",
      "    policy_freq     \t         2          \t   <class 'int'>    \n",
      "      actor_lr      \t       0.001        \t  <class 'float'>   \n",
      "     critic_lr      \t       0.001        \t  <class 'float'>   \n",
      "  actor_hidden_dim  \t        256         \t   <class 'int'>    \n",
      " critic_hidden_dim  \t        256         \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "        tau         \t       0.005        \t  <class 'float'>   \n",
      "    policy_noise    \t        0.2         \t  <class 'float'>   \n",
      "     expl_noise     \t        0.1         \t  <class 'float'>   \n",
      "     noise_clip     \t        0.5         \t  <class 'float'>   \n",
      "     batch_size     \t        100         \t   <class 'int'>    \n",
      "    buffer_size     \t        8000        \t   <class 'int'>    \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/100，奖励：-1136.72\n",
      "回合：20/100，奖励：-245.70\n",
      "回合：30/100，奖励：-491.43\n",
      "回合：40/100，奖励：-346.12\n",
      "回合：50/100，奖励：-125.15\n",
      "回合：60/100，奖励：-3.26\n",
      "回合：70/100，奖励：-129.26\n",
      "回合：80/100，奖励：-1.01\n",
      "回合：90/100，奖励：-125.80\n",
      "回合：100/100，奖励：-116.20\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAHJCAYAAACBuOOtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADGl0lEQVR4nOydd5wcdf3/nzPbbq9frqf3ShISkkAooUrvdrqAqIgooIDCD1RUVBAUMBQBQbooNkBAQQH5hgRCIJCQXi/J9X63feb3x+zMltu9273b27tL3s/HI4/L7czOfOZzU17zroqu6zqCIAiCIAj7MepQD0AQBEEQBGGwEcEjCIIgCMJ+jwgeQRAEQRD2e0TwCIIgCIKw3yOCRxAEQRCE/R4RPIIgCIIg7PeI4BEEQRAEYb9HBI8gCIIgCPs9IniEjCJ1LAVBEIThiAgeIWO8/vrr3HDDDRnZ1gsvvMCMGTOoqakZ1O8IBxaPPfYYRxxxBPPmzWP58uUxy2pqapgxY0af/1auXJlw3YMOOojDDz+cb3zjG3zwwQc99l1bW8u1117LYYcdxsKFC/nmN7/Jjh07+hzzHXfcwZIlSzj44IP561//mqGZMFi5cmWP45g5cyYLFy7kS1/6Em+88UZG95fKWFauXDmo3xlqfv7zn3PhhRcO9TAOSOxDPQBh/+Gxxx7L2LaOOeYYnnvuOSoqKgb1O8KBQ2dnJ7/4xS845phjuPTSSxk7dmzM8oqKCp577jnr94aGBq666iq+8Y1vcMwxx1ifT506ldbWVoCYZT6fj9raWp544gnOP/987r33Xk444QQAuru7ueSSS1AUhR/+8Ic4nU6WL1/OBRdcwIsvvkhxcXHCMW/atImHH36YL3zhC5x11llMnjw5Y/MRzS233MKcOXMAw0rb1tbGo48+ypVXXsmDDz7I0UcfPSj7PdB49NFH+f3vf8+SJUuGeigHJCJ4hGHJqFGjGDVq1KB/RzhwaGtrQ9M0TjjhBBYvXtxjudPp5OCDD7Z+Ny2F48ePj/kcsARPomWnnHIKF1xwATfddBOHHXYY+fn5vPrqq2zfvp0XX3yRadOmATB9+nSOP/54XnnlFb70pS8lHLO5n9NOO41Fixalf9ApMnXq1B7HsWjRIo455hj+8Ic/iOAZILt37+YXv/gFb7zxBgUFBUM9nAMWcWkJGeHCCy9k1apVrFq1yjIxm+bmZ599lmOPPZaFCxfyzjvvAPD8889z7rnncvDBBzNv3jzOOuss/vnPf1rbi3dP3XjjjVxyySX8+c9/5qSTTuKggw7irLPO4q233hrQdwDWrFnD+eefz8EHH8wxxxzD448/ziWXXMKNN97Y6zF/+OGHXHrppSxcuJDDDjuMa6+9lrq6uoRjMTnuuONitjtjxgzuu+8+zj33XObNm8d9993HrFmzePLJJ2O+19zczJw5cywrmqZpPPTQQ3zmM5/hoIMO4qSTTuKJJ57o8+/U0dHB7bffzgknnMDcuXM5/fTT+dOf/tRjjPfccw+/+MUvOPzww5k3bx6XXXZZn+4Xv9/Pr3/9a44//njmzZvH6aefzl/+8hdr+YUXXsiNN97IAw88wOGHH84hhxzClVdeyZ49e6x1brzxRo477riY7ZruoxdeeKHX/b/zzjucd955HHLIIRx66KFcd9117Nu3DzD+HuZ2f/CDHzBjxow+56q/OJ1OvvWtb9Ha2mqd0yeccALPPPOMJXYAHA4HYFiGEnHvvfdaro+LL77YGn8oFOKpp57ijDPOYN68eRxzzDHceeedMdu58cYbufjii7n11ltZuHAhp556KqFQKK3jyM/PZ9KkSezdu9f6rLW1lVtuuYXDDz+cuXPn8oUvfIEVK1bEfG/GjBk89dRT3HTTTSxZsoQFCxbw7W9/m8bGxpj1nn32WU466STmzZvHBRdcELMf8/gT/Z1mzJjBvffem3DMqZw/5n1pxYoVXHjhhdYcPv/889TX13PVVVexYMECjj766D6t1g888AAHHXQQbW1tMZ8/9thjzJkzh6amJgBuv/12du7cyeOPP86sWbN63aYweIjgETLCrbfeyuzZs5k9ezbPPfecZR4HuO+++7jhhhu45ZZbWLBgAU899RS33HILJ5xwAg8++CB33nknTqeT7373u9TW1ibdxyeffMIjjzzC1VdfzW9/+1tsNhvf+ta3etxs0vnO1q1bueSSSwC46667+Na3vsVDDz3E6tWrez3e9evXc8EFF+Dz+fjlL3/Jj370Iz755BMuu+wygsFgGjNn3DTPOOMM7rnnHk466SSWLFnCSy+9FLPOK6+8gq7rnHbaaQD88Ic/5J577uHMM8/kgQce4OSTT+ZnP/sZv/3tb5Pux+v1ct555/GPf/yDyy+/nOXLl3PIIYdw00038cADD8Ss+4c//IFt27Zx++2385Of/IRPPvmkz/is7373u/z+97/n85//PA8++CBHHnkkN954Iy+++KK1zuuvv84LL7zAzTffzI9+9CM+/fRTLrzwQjweT1pzFs9f//pXLr30Uqqrq7nrrrv4/ve/z5o1a/jiF79IU1MTxxxzDPfddx9guKGiXVeDwdKlS1FV1YrlKSgoYOHChYAhDDds2MCNN95ISUkJp5xySsJtfP7zn+eWW24BDJeTOf5bbrnFEq33338/559/Pk8++SRXXnllTNLA+++/z759+/jtb3/Lddddh81mS+sY/H4/NTU1jB8/HjCE2cUXX8zrr7/ONddcw3333UdVVRWXX355D9Fz9913o2kad911F9dffz3/+c9/+NnPfmYtf/LJJ7n11ls5+uijWb58OfPnz+f//b//l9b4Bsq1117Lcccdx4MPPsikSZO49dZbueiii5g2bRrLly9n3rx53H777axduzbpNs444wyCwSCvvfZazOcvvfQSRx55JKWlpQB85zvf4e9//3tCy6KQPcSlJWSEqVOnkp+fD9DDNH7eeedx8sknW7/v3r2byy67jCuvvNL6bMyYMZx77rmsXr3aeqjH09HRwQsvvGDdgHNzc7ngggt49913Oemkk/r1nQcffJCCggIefvhh3G43AJMnT07qYjB54IEHKC4u5tFHH8XlcgFGDMh1113H5s2be/1uPIsWLeIrX/mK9ftZZ53FD37wA/bu3cvo0aMB4wZ6+OGHU15ezvbt2/njH//ItddeyxVXXAHAkUceiaIoPPjgg5x33nmUlJT02M8LL7zApk2bePbZZ1mwYAEARx11FMFgkOXLl/OlL33JiiUpLCxk+fLl1kNy165d3HvvvbS0tCTc9qZNm3j11Vf5wQ9+wMUXXwwYD/09e/awcuVKTj/9dAA8Hg8vvPAC48aNA4y5Puecc/jrX//Kl7/85bTmzUTTNO68806OPPJIfvWrX1mfm5aNRx55hOuvv956s07khso0drudkpISGhoaeiz7xje+wf/+9z9UVeWnP/1p0pizqqoqpk6dChjX1+zZs9myZQt/+tOfuO6666y//RFHHEFFRQXXX389b731luV+CgaD/PjHP6aqqqrP8WqaZgn1YDDInj17WL58Oc3NzZx//vkA/O1vf2PDhg388Y9/ZP78+QAsW7aMCy+8kDvvvJM///nP1vamT5/O7bffbv2+du1aXnnlFcCIEVq+fDmnnnoqP/jBDwDj/O3s7OTZZ5/tc6yZ4rOf/ax13eXm5vKFL3yBefPm8e1vfxuAmTNn8tprr/HBBx8wb968hNsYM2YMixcv5sUXX+Tzn/88YFwra9eu5e6777bWmz59+iAfjZAKYuERBp14E+6NN97Id7/7Xdrb2/nwww/529/+xlNPPQUYb5XJGDVqlCVcAOtG3pt1oK/vvPvuuyxbtswSOwALFixgzJgxvR7T6tWrWbZsmSV2zO+98cYbaZus49c/8cQTcblcvPzyywDs27eP1atXc9ZZZ1lj1nWd4447jmAwaP077rjj8Pl8Sa1Tq1atYsyYMZbYMTnzzDPx+Xx89NFH1mdz586NsQj0NdfmPk888cSYz++9915uu+026/eFCxdaYgdg9uzZjBs3jvfeey/hdlNh+/btNDQ0WKLKZPz48SxYsIBVq1b1e9sDQdd1FEXp8fk3vvENHnvsMc4++2y+//3v8/zzz6e8TfNY4l8KTjvtNGw2W0y2UnFxcUpiB+CSSy5hzpw5zJkzh/nz53PqqaeyYsUKbr75ZpYtWwbAihUrKC8vZ86cOdY5FwqFOPbYY/nkk09iLK3xgrKqqso6d7Zt20ZTUxPHHntszDrJLF2DRfR1YFpiTCEHWMK+o6MDMFyJ0debpmmAcf289957lrh96aWXyM/P7+FaE4YesfAIg05ubm7M77t27eKWW25hxYoVOBwOJk+ezMyZM4He6/hEixLAepiYN57+fKe5udm62UVTVlaWdJtgxDIk+l5/iJ+f/Px8TjjhBF566SUuv/xyXn75Zdxut5XxEx3ImggzjiietrY2ysvLe3xuHmt7e7v1Wfy8qarxbpRsrs0x9TUnlZWVPT4rLS3t1S3ZF+a+E/3NysrKWL9+fb+33V88Hg9tbW0JBYcZfGxawB544AHLOtAX5jzF/x1Ni5L5cAbIy8tLebw/+tGPLDe0zWajqKiI0aNHxwi21tZWGhoaYtzV0TQ0NFBUVAQkPn/Ma9s8hnhLYaJzczAxLdLRxI87ms985jMx8WbnnHMOP//5zzn55JO57bbb+Oc//8lFF13ESy+9xEknnUROTs6gjFvoPyJ4hKyiaRpXXHEFDoeDP/3pT8yaNQu73c6WLVv429/+lvXxVFVV9QimBGhqauo1BbigoIDm5uYen7/55pvMmjUrqRjr6upKaVxnnnkmV1xxBTt37rRuoObNuLCwEIDHH3884UPNdIPFU1RUxM6dO3t8br6ZJnJVpYo5pubm5piH/NatW2ltbeWQQw4BoKWlpcd3GxsbLSucoig9gmu7u7t73bfphkv0d2xoaBjQcfWXVatWEQqFrJiNtWvXUlNTw6mnnhqz3pw5c1izZk3K2zUFRUNDQ4wVMhAIJHU3psKkSZOYO3dur+sUFBQwceJE7rzzzoTL49P8k2GO0QzoNTGFq4l5DYVCIcva2Nf105/zJ1Xuv//+GAu0eRwFBQUcd9xx/POf/+Swww5j8+bNWY9HElJDXFpCxjCtAL3R0tLC9u3b+dznPsfcuXOx2w3NbWZO9WatGQwWL17M22+/HZPhsn79+j6LFy5atIh33nkn5ga4fv16rrjiCtatW2e9PUYHYZsP/1Q48sgjKSsr4w9/+APr1q2z3FnmvsGYy7lz51r/mpub+c1vfpN0H4sXL2bPnj09HrB///vfcTgcSeMUUsEUNPGF6u68805++tOfWr+vXr06RvR88skn1NTUsHTpUsCwSrS0tMT8PfoKIJ80aRLl5eUxwdFgxIp9+OGHVrBwtjBjosrKyvjMZz4DGOf39773PStrDIwH+bvvvptWxphZvyU+qP2ll14iFApZf4fBYMmSJezbt4/S0tKY8+6dd97h4YcfTjkoeuLEiVRXV1sxPSb/+c9/Yn5PdA31dS705/xJlRkzZsQcd7TAO+uss/jwww955plnGD16tNTZGaaIhUfIGIWFhaxZs4YVK1Ywe/bshOuUlpYyZswYnnrqKaqqqigsLOTtt9/mD3/4A9B7PM5g8PWvf52XX36Zyy+/nEsvvZT29nZ+85vfoKpqwvgLkyuvvJIvfvGLfO1rX+Oiiy7C6/Xy61//mnnz5nHEEUfg9XrJycnh5z//Od/+9rfp6urinnvuSVpgLh6bzcZpp53Gk08+SWVlJYceeqi1bMaMGZx55pn8v//3/9izZw8HHXQQ27dv5+6772bs2LFMnDgx4TbPPfdcnn76ab75zW9y9dVXM3bsWN544w3+/Oc/c9VVV1lWmv4wc+ZMTj75ZO644w68Xi+zZs3irbfe4j//+Y+VXQTG3/fyyy/nG9/4Bl1dXdx9991Mnz7dir859thjeeKJJ7jpppv43Oc+x6ZNm/j973/f68NUVVWuvfZavv/973Pddddx5pln0tLSwn333UdRUVFMQHim2bVrFx9++CFgWFlqamp49tlnWbduHb/97W8tq9yXvvQlnn32Wb72ta9x1VVX4XA4ePrpp9m0aROPPPJIyvubOnUq55xzDvfccw8ej4fFixfz6aefct9993HooYdy1FFHDcZhAsb58+STT/KVr3yFr3/961RXV/N///d//O53v+OCCy6w0uz7QlEUvvvd73Lddddx8803c/LJJ1tiIZqjjz6a22+/nVtuuYXLLrvMyjjrzVXXn/MnExx11FEUFxfz3HPPcfnll/d67xCGDhE8QsY4//zz+eSTT/jqV7/K7bffnjT7ZPny5fz0pz/lxhtvxOl0MnXqVO6//35+9rOf8f7772e17PqECRN45JFH+OUvf8nVV19NaWkpX/va17j//vt7vbHOnj2bJ554gl/96ld85zvfIT8/n6OPPprvfve7OJ1OnE4n9957L7/61a/45je/yZgxY7jqqqvSag1w1lln8fjjj3P66af3sJ7dfvvtPPjggzz77LPU1tZSWlrKqaeeyne+852kN3e3222N+Te/+Q2dnZ1MnjyZn/70p3zuc59LeVzJuOOOO7jvvvt4/PHHaWlpYcqUKdxzzz1W7BEY1qnDDjuMm266CTBq/lx//fU4nU7AyDi64YYbeOKJJ3j11VeZM2cO9913X59Zc+eeey55eXk8+OCDfPOb3yQ/P5+jjjqKa6+9dlBjQ+6//37uv/9+wIijGTVqFIsWLYqpXAxGLNEzzzzDHXfcwa233kp3dzfz5s3j8ccfT7ug4E9/+lMmTJjAn//8Z373u99RUVHBRRddxJVXXpmSlbW/5Obm8tRTT/GrX/2KO+64g46ODsaMGcN1113HpZdemta2zHN6+fLl/O1vf2P69On8+Mc/5tprr7XWmTRpEr/4xS+4//77ueKKK5gyZQq33XZbTBB8PP09fwaK3W7ntNNO44knnuDMM88c1H0J/UfRpdujcABjBk5HP3Ta29s5/PDDuf7667nooouGcHT7F6aQTaVAoiAIQqYRC49wQLNu3Truuecerr32WubMmUNrayu///3vKSgo6JHmLAiCIIxcRPAIBzSXXnopfr+fZ555hn379pGbm8uSJUu4/fbbpS+XIAjCfoS4tARBEARB2O+RtHRBEARBEPZ7RPAIgiAIgrDfI4JHEARBEIT9HhE8giAIgiDs90iWVhhd19G0wYnfVlVl0LYtxCJznT1krrOHzHX2kLnOHpmYa1VVUq5sLYInjKbpNDen1tgxHex2lZKSPNrbuwkGs9sn6kBD5jp7yFxnD5nr7CFznT0yNdejRuVhs6UmeMSlJQiCIAjCfo8IHkEQBEEQ9ntE8AiCIAiCsN8jgkcQBEEQhP0eETyCIAiCIOz3iOARBEEQBGG/RwSPIAiCIAj7PSJ4BEEQBEHY7xHBIwiCIAjCfo8IHkEQBEEQ9ntGrODRNI177rmHo446ioMPPpivfvWr7N69e6iHJQiCIAjCMGTECp7ly5fz9NNPc9ttt/Hss8+iaRqXX345fr9/qIcmCIIgCMIwY0QKHr/fz6OPPsrVV1/NMcccw8yZM7n77rupra3ltddeG+rhCYIgCIIwzBiR3dI3bNhAV1cXS5cutT4rLCxk9uzZvPfee5x++un92q7dnnn9Z7OpMT+FwWOw5joY0nj7o30smF5Gcb4r4TohTeO1Vbs5aHIp4yryM7r/4Ug2z+vWTh97G7uYNaEERUmtK/JIJhjSsEfNa/xcB0Maa7c20dkdIKTp6LpOSNOpLs3loMmlQzLmoeb9DfUU57uYOrYo5e/4AyHe+mgvh86upCDXCYzM+3UwpPHqyl0snFFOdWle1vcf0ozzcc7EUTgdtpS/NxRzPSIFT21tLQDV1dUxn1dUVFjL0kVVFUpKBu9kKSx0D9q2hVgyPdcv/m8bv3/5U3bWj+OaLy9MuM47H+3lmX9vZsH0Vn78tcMzuv/hTDbO67ue+4gPNzdwx7eOYubEUYO+v6Hk9fd2cd/zH3HjRYs49KDY+5s516++u4P7nv+ox3cVBR648XhGlyUW3H99cwv/t3Yf/++yQ60H/P7A3oZO7vnTWkqLcnjslpNS/t7zr2/iD69spKHNx5Wfmx+zbCTdr19ZsYPn3tjClr3t/PCrS/v+Qob565tbeeTvn/D546dx0amz0/5+Nud6RAoej8cDgNMZe9G6XC7a2tr6tU1N02lv7x7w2OKx2VQKC920t3sIhbSMb1+IMFhzvXZTAwCfbm+ipaUr4TqfbDHWaenwJl1nfyJb57Wm6azf0QTAph1NVBYltrDtL6z6ZB/BkMaqdfuYPqYQ6DnXm3c2A1BZ4mZ0eR42VWFzTRttnX4+WF+Le251j+3qus6fXt9MW5ef/763kyPnjc7qcQ0mazbUAdDU5qWhsSPGOtYbH282rtlPtjZa1+xIvF+v29oIwKZdLTQ3d2bdCvrhRmP+12ys54ylE1L+XqbmurDQnbKVaEQKnpycHMCI5TH/D+Dz+XC7+68Wg8HBO8FDIW1Qty9EyPRc76htB6C2uZtuTyCh2XZXXQcA/sCB9Xce7PN6b2MX/oCx/bZO/34/ty0dPuNnu6/HsZpzba5z7IIxnLhkPABP/2sT/15dw/a97Rw6q7LHdpvbvbR1GQkdO/Z1cNjs/Wced+xrt/7f1umnKC8169WOWuOa3dPQRZcngCvquh5J9+ud4ftTR3eAhhYPowpz+vhGpvdvzOOu2g78/hCqmp7gyuZcjxxHZRSmK6u+vj7m8/r6eiore17sgtBffIEQtc2G5U/XYW9TYutNTUMnYMQFCJnDFJIA7d37fwZme1iUtHX6kq7T2mmsUxQVTzahqgCIPHziif58d33ngMc5nNgddY50pniOtHf5LeGo6fqInZOQplHTELkn7arL7nF0ewM0tnkB8Ac19iW5Pw4XRqTgmTlzJvn5+axcudL6rL29nfXr17N48eIhHJmwv1HT0ImuR35PdGPs8gZobjdunoER8lY4Uoi+gXd07f+Cx7TCtPZyrKYYKs6PWDImVBqCZ1d9B1r0CRtmR5Tg2VXXgZ5gnZGIruvsjDpHOj2BlL4XLaQhuVAc7tQ2e2LuOfHHNdjE3w93Znn/6TIiBY/T6eSCCy7gzjvv5PXXX2fDhg1cc801VFVVceKJJw718IT9iPg3pj0NPd9gaqIuer8InowSfQPtSPFhNlIJhjTrgd3a6UsqSkwxFG3hqS7LxWFX8fhCNLR6enwneh67vEHLujHSae30x4icju7UzpH4B3O0W2wksTvuOHZl2VIVf3/cWTu8LWUjUvAAXH311Xzuc5/j5ptv5stf/jI2m41HHnkEh8Mx1EMT9iPMN6ai8Nt0IgtPtEk5EBSXVqbQdT3WpbWfW3iij88f0PD6e55LXn8QX/jz6FgVm6oyttzIzoq3Vui6bll47DYjviLbD8bBIt6ikaooNudo+rhiINYCNpIw/46jy4wM42xbeHbVG/srLzbihsx4ouHKiBU8NpuN733ve6xYsYI1a9bw0EMPMXbs2KEelrCfYb7BLJ1TBRiCJ/7NO1oEBUM6mrZ/uAuGmuZ2H13eoPV7x34ew9MWJ+haE8TxmOs4HSo5ztjgeSuOJ+6h19rpp73Lj6LA/CllwP4TxxP/gE81hseco2XzjXjQvU1dlpAcSZgWniPmGvenxjYvXd7sWUJ3h++PR4YzA3fWdyZ0qQ4XRqzgEYTBxggINC7ow2ZXoihGjEC8pcFcx0TieDKD+TDLdRnJpB3dgf0m9iQRbZ3+Xn+P/qw4z9Uj/XhCpWHh2VWb2F0zuiyPyeFU9/1G8ISPw8ywSsXC0+0N0NBqBNrOm1JGcb4TXY9YK0YK0fFLM8eXUFZkWFmyFbgcDGnsaTSs20tmV+K0q/j8IeqaM1/eJVOI4BGEJNQ2dRMIaricNsZW5FNZkgvA7iiBo+l6D8HjF7dWRjDfwmdPLAGM+CjffpwF19rl6/V3iFh9ivJ7pl5PrDLEzM66WCuk6a6ZWFXA+ArDChQf+zFSMS0MM8YXA9CZQgyPKQhKC3PIdzuseduxb2TNiRm/pCoKY8ryGG8Grmfpb7u3sYuQpuN22akodlsV5odz4LIIHkFIgvn2OK4iH1VRGBu+oGvqIzE7Da0e/AENh13FFq4/IRaezGBaIaaNLcYZbvvSnmJQ6kikPQ0LT1GCFiejy4wihJ2eSNYgRB5AE6sKrYdSfYsHrz/YYxsjiW5vkPpwgPbsCYYoTsXCY86H6QKcGP65Y5jHn8RjCpvq0lycDhvjTQtflgSHeX2Or8hHUZQ+SyMMB0TwCEISzBvHhPBb8bhyIzAw2h1QExU06HQYl5NkamUGc/7HV+ZbrRD25zie+BieRILHtPoUJyiu57CrjAmfo6ZVJzpgeUJVAYV5TorynejEBtuPREzL6qhCF1WlhvU1NQtPeD7CAmFitSl4hu+DOhHWC1n4OCIWnuy4tMz9mPs3SyOI4BGEEUj8BW1ZeKJcWKb4GVeej8NuxBFI8cGB0+kJ0BS2UoyrKKAg18i+7Ojafy08puAxYzESubQiFp7E1YSth074oR4dsGxad8yfIz2OxxLEFQXku4356PT0LYjNuBdTIEwIu7Rqm7rx+EaO1Wt31PEbP42/676m7qzcg3bXx+4/EjTfM7FjuCCCRxASEJ0SbT5ExoXTfvc2dhEM934x35LHVuRbbhex8Awcc+7Li3PIzbFTGLZo7M/Vls2Cgub5ltilZRYdTNxTzHzomPNnumlGl+VZgb37SxxPtMvZEsR9WHh8/pBVDdicq6I8J6MKXegMb+tEPPEWnpICF/luB5quW8HEg4VxfzSFo7H/0WV52G0qHl8wYS2o4YAIHkFIgJkSbVMVq8ZFaVEOOU4bIU232k2Y1p5x5XlWj62AWHgGzK64t/DIA20/FjxhC4/5AEmUlh4pOtiHhSf84DYDcSeGP4f90MJTWUC+2zg/+gps3x2unF6U54wRjea8bR8hBQg9viD1LYaoMC07iqJYbrrBDhxuavfS7Yu9P9ptKuMq8sL7H57nlggeQUhAJCAwD0fYcqPEBC534vUHaQjfdMZU5FvriYVn4EQ/zICoGJ7906Wl67oleEzLQ19p6YkYW5GPohjiqbXTFwlYri601hlnuWa7RmzNqGBIY2/YijG+Mp8cp80qqthbHE/8eWVizs9IETzmi1ZJgcu6NiB7cTy7o2IXo7vTm8JxuAaAi+ARhATsjAtsNDHdWrsbOtnT2IWO8bZYmOu0XFqSpTVw4ue/MHf/dml5fEHrvDEfWt2+YEwsRnTriWQWHpfDxujSSOBydMCySdWoXKNmSiBkZTmNNPY1dRMMGSnRZUU5KIpiWXl666e105qP2Ot6kpmpNUJS0y0LaEXscWQrNX13kv1bLtVh6hoUwSMICYh3qZhEp6abGVrmZ5EYHnFpDYToDvU9XVr7p4XHtO64XXaK8pyWtTA6c8vskm5TIw/3RJhztnZLY4+AZQBVVaxsrpHq1ooELOdbBRhTyeTbGReXZ2I+qGubu+kaAT3bzIDhcXHHYbpDa+o7B9V6F4kfSjyPO2qHZ4NaETyCkAArAyGJhaemodOqx2N+ZmVpiYVnQNTUG3EWhVFxFtbDbD/tp2VlX+U5URTF6pMVHcfTFlV0ML7KcjTmQ+fd9XVAbMCyybiK7BapyzTxGZSAJQKT1eIJhjSr+W/8i0xBrpPSQiM7buue1kwPN+Mks/BUjsrF5bDhD2rsG8SKx9GCM5oxZfnYVIUub5Cmdu+g7b+/iOARhDjiU6KjMd+MWzp8bNjVAsDYcKCeWYcnEBDBMxCi6++YFOYZD7P91aVlWnJMoWMKveg4HqvKcpL4HRPTDWg2H50Y93CHkR+4HJ8SDRErYLIYnj0NRmXg3LAbLB6zHs+W3W2ZHm5GMVreROKXolEVxfrbDpaY7fYGaGwzxMy4uP1H14IajhlvIngEIY74lOho3FE3SzP1c6xl4RGXViYwMzyi3Q6FUUHLw9FUPlDa4lpGmD9jLTyxoigZ8daL6PidyDojV/AkSomGvi080RWWE1nIzIrLW2paMzncjFPb1E0wpJHjtFFW7O6xfLArLpvnTGmhi7ycnq7ViUma2A4HRPAIQhzJ4ndMouMhbKpCdThI1Bl2aUnQ8sBIlEljvr2HNH1EFYdLlYiFx7DemFlYsTE8Zg2e3gWP22WnsiTyIIzO0DIxRXpLh6/XIF8w3LdrtzaybW879a0ePL7gkIrOpraeKdEQcXsm65ieLH7HxOyptWV3awZHm3niW97EM9iZWpH9J57HSGmEyP6DIY3GNs+Qd1K3972KIBxY7KpP7J82GVuez5rNjQBUleZalp1spqUHQxqqqiS84Q2UNZsaqCrNtYRcIjRdp6Pbz76mLto6/HR4/Og6zJ1cas1Df0hmrnfYbeQ4bXj9Idq7A+QmeLMcybTF1ddJZOFp7aWPVjwTqgqoa/H0CFg2cbvslBfn0NDqZXddB7Mmjko8rk4fP37sfavQponLYePIedWctnRCjyKIIU3jg02NfLi5gYqSXOZMHMWk0QXY1My8X5sP3DFxKdF9WXgSuUqjMS1h+5q6eOHNrSybPzphgcfmdi+NbV6K8p0U57lwOY0XHY8vyMZdrazf0cz6nS10eQJcf96CpNfRB5saeObfm/jG2XOZPLqnKE1GJEMqseCItvCY5Q7qmruN8wHjb+/OsZPrsjOqMKdXi+G+pi7+/X4Nk0cXsnB6OW6XPbL/pPNoHMu2va08/vI69ta1UtfUQTCkcdzSGZy7bErKx5ppRPAIQhzpWHjMN2XAKjw40LLu/3hnO7vqO3HaVRx2G067iqoqtHT4aGr30tTupa3TT3VpLj+6dEnMTX+g7Kht594XPmZ8RT4/vHRJwnWCIY3bHn0/oTvk88dO4ZRDJ/R7//uizPXlceb6wlwnXr+H9i4/VaNyY5Z1egJ8tKURf1BD03Q0TSek6eS57YwuzaO6NHdYiyTLpZUXK3gSxvD0YeEB4y171af1CQOWTcZXFNDQ6mVXfWdSwbNtbzvBkIbToVLgdtDhCeAPGMX9Xl9dw1sf7eXYBWM45bAJuBwqb6/dx7/e223FeAD87X/bcbtszBxfwriKfDTdEEWhkI6m6+TnOCgucFGcbwSpF+QaWWoOm4rdrmBTVXz+EB3dfjo8AT4Mv2z0DDxOHsOjabp1viZy8YEhmGaOL2bDrlb++vZ2/vHODhbNrODo+aPp9AT4dGcL63c0U9cSm8rvdtkocDtpbPP2sGB8sKmB05YmFjxvfbSXpnYf/1u7t1fBo+mGVbPTE6DTE2Bj2AIVHz9jEh04fOXdb+ELx3KpaNgJYVc0bGjYlRAB7Hz7/COYMqYo4bb+8c4O3l1fx3/W7OEPr25k/pRSq9TBuIoC9IAX/4cvEdjwJnrAB7pOORq/KtFQ0VBrwhsKH16992RABI8gDAs0Tae2ychuSPRmDJE0dICx5ZGbWSZaS+xt7OIvb29Pad19Td3sbexKKsz6w6ZwwGZtSze6rieMdaht6rYeHm6XjbwcB7qu09TuY0tNGxza//2bb+GJzPUFeQ7qWz0JU9Ofe2Mz73xc2+u2i/KcVJfmUlbkpqwoh9KiHMqKchhXUdAjVitd3ttQzwebGrjklJlJBUZvxFt4TMtCawLBk6zoYDSHzq5k5ad1HLdwbNJ1xlXks3pTQ69xPKYbaPHMCi47bTZglA3YsqeNv729nS172njtvd3898M92FWV7rC7Md/t4PCDqmju8PHpjma6vEHWbG60LKPpoCiQyBMS/8Av6MXC09zhxR/QsKkKlSURsayHgui+TnR/N/i6ufYoOzW1Nt5ft5f65k7Yspm3t2o4CeFQghyiBHHlBilwghYKoGpBbIqGPajhyg+Qbw+R79CwaT48AYXd2xegH3IeirNnrI0579t7qf2zfkcz977wsSVaojEtLMG9n+L/6GV0byeEgqCFuLWkCy0YwKGEcOSFcBBCVRK7k+reXod28oWoxVU9lpnWtMI8J+1dft7f2ACAgs5Ezyd0Pfc39O7WHt+zJzI82xyMG1+d9FizgQgeQYii0xOw3tKSvUlXFLtx2lX8QS1GFGWi8KCZ2VA1Kpdl80cTCIbwBzVCmk5xnpPS8IP6ydc2sW1vO3saMit4zAqp/oCGxxdKKARawg/eidWF/PiyJQSDGut3NHPnsx9aab/9xUz1T2SuL3Anr7NivnVOH1dMYZ4Tm6qghisO72vqpqXDR1uXPywsWmO+W5Tv5JdfX2qVFYjn050t1DV3c8yCMUnH/c93d7KjtoPFMytYOL08lUONIT6Gx7T0tHUlCFpOwcIzqjCHH34lsYXOZFwKwa3mQzn6HHM5bMyZOIrZE0pYt6OZv7y1ne372vGjUVni5sQl4zn8oCpL+Gmazq76DtZtb6apzYtNVbHZFGyqgqIodHoCtHb6wv/8dHT7YwSO+X+7TaUg10FBroOKklwOm10JQKh5N75Vf6JcycOtjKezu6clr6HVsDiVFeWgqgp6wIvv/b8QWPc6aLExYaXASQCJ33ciJDOshjeXa4PSzrfpemYNjvmn4JxzPIrDSHjo9ARo7fDiIERNQyeBYCjh+bfik1pL7LgcNvLddvLcDqaMLmJsQQjP6w8Q3Ppuj+8VAfSquxVCig2bHqSyfR1dz/8Ax4wjcS48CzW/FAB/IEB7cwvlqpcbz5xDd2cnG7fVU7OnjiMd63CuqkMHlIJyXId+AVvZREOdKgooKigqis0ONjuoDpQMuTQHgggeQYjCTHvOdzuSxhyoqsLJh45nc00bM8aXWJ87MuDSMh/ccyaN4uRDxyddb3xlgSF4MtwkMPpts6XTl1DwtHYYD+HSqNRe07XX0OrB5w9ZcQ3pEimo1vNpkyw1XdN06poNN8Olp82iIkHmiscXpLa5m9qmbhrbPDSF4zA27W6jrdPPrrrOhGZ9Tde5/6+f0OkJMGtiSYx1IBpT5LZ09Ox/1RfBkGa5YeLT0ju6AwRDhuC12kqkEMOTCmaQ7p7GLrz+IDnOnn/rZPVWwGi1ctCkUuZMHMWm3a2ENJ2ZE0p6WOZUVWFiVaG1v1QIaRrBoE4gpBEIGi7OHKctxuKoB334Vv4R/9pXQQ/hAm4o/JCnu49E0/WYcZjNLMtL3AR2rMb3zlPoXc3mkYDTjeLKQ3Xl4nDnEtQUdPOhrdrA7kSxO8HuCv90gs2BooYf6DY7it2F4swBh5vOgMrTf/ovJ7nXUuHrwL/qeQJrX0Etn4TuaSPY0cKvSjqwKTqbAlXUrYExC49EscWKtc17DIvrtz83j/lTy4zj1kIE1v0bzx/vhoAXFAXHrGOxj58Hqh1UuzFmmx1sThS7wxirzQF2h7GOovLpzhaefv4Nzi1cyzR2EdjwFoFN/4daXI3u7UDztPPT4vDL26t/pRBYDCxWgRDgyMG54Eyccz/TY9zDFRE8ghCFWdjOjAdIxtlHTe7xWWYsPIaFJVkmicmYcHbKnobMZWJ0e4PURRUra+3wWfuJxrTwjCqMCJ7CPCeFuQ7auwPsaexKKwgzGtOiEB0bZZKsn1ZTu5dgSMNuUykr7FlfBYxAzUnVhUyKy1j69fMfsXZrEztqOxIKnvoWj5XF1Ft2WDBc1TZRw8++6OgOoGPUUMkPn3f5uQ5sqkJI02nv8mN3+dB0HYWI8BsoJQUuSgpctHT42LGvg5kTSmKW91aPKhpFUWKEfyawqSo2J7iSmCmCu9fi/d8f0DsMF5l9wgJCLXsoaa/nG/mv0fUO5C/9vPUgbmzuoNrWwum+FXhf22yMu6CcnCMvxDb2IBTFuHbtdpWSkjxaWroIDuA6LtJ1Nthq+aBtEj8+Dgq3vYbeXk9o91rj+ADCemy6oxbWPE7X+j9jn34Etsqp6N4OPO2tHOnbREGel8mfvkfXR53ong7DdRW2Sqnlk8k56iLDupIm4yry2RsaxX0tx3Df+aPhw78Q2rcRrXk3UcPDh5Oc3FxwuAxRZ3ehlo3HueAM1Nzifs/RUCCCRxCiaA8/TAtz+3YbxDPQLC1N19kZfuBPTBJYaWIJngxaeHbGNfxL9vCOWHhiLSljyvNp39lCTUNnvwRPW5ef9u4AihIp8BhNstYB+8IxV5UlblQ1vay1iVUFrN3alLRp5Pa9kc9DoeQptaFwFlNrPyw8ptuqMM9hWSVURaEwz0lLh+HqUezGrbogN7nlsT9MGV3I+xsb2LavvYfg2d1LParBRA940bqa0Ttb0Lua0bpa0LtarJ96dwu6x/i7KPml5BxxAfYJC9ADXl5/6C4OdWyC9a/RtWctijMXvbOJz3ja+EwR4AEUG875p+BceKZhrRkElHABwE93BtjqmsmRXziW4M416L4u1Nwi/r66hbc2dZHngINtm1iWt41cXyeBj18l8PGrgOExO9rU7/sg+q6iuPJxLvkcjpnLLLGWLgW5TorznbR2+tmrVDPl9BvRGraj+zpR3IX8Y3UTL61p5thDJnDeZ6YPaD6GCyJ4BCEK011S0Edxt0RE6vD0z6VV19yNzx/CYVepLkvsOjEZHRYEjW3eAbmQotkeVxk1mXumJYFLCwyrzKdhwdMfTHdWZUluwsDfwrD1oz2uvYTZd6uqtPc5S4RZo2ZHkqqw26KEUHxqdjTmspZ+WHgiBQVjXVVFluDxo6vGfKSSkp4Ok0cXGYJnb0/Bt7OP9Of+omsaemcjWlstWlsdWkcjekcjWkcjWmcj+FIQ8YqK46DP4Fp0jhUXozhy+JftGNZ2jOGy0vdQ22qJlqh+3UZg1GTKj78E26jk8ViZwhA8Leyu70RRR+OYtMha9vEb79Gu6xw8q5p/fpTLh+7D+NFJuQQ2vo3maUPNKWB7i86GuiCV1RUsOXgKirsAJafQ+JlbZLjTBsjYinxaO5vZ3dDJ1LFF2CoilustLS2EsMUkaYx0RPAIQhSm9aAvl1YiHI6BWXh2RmUo9fUWX5gbcSHtberq4arpDzvCD3eX04bPH0pq4TEf6j0Fj+lm65/VaXdcM9Z4TBEan4VjCZ5R6Qses0v2vsYuPL4gblfsLTHa8hPspRljKLysPzE88RlaJkasTgetHT70sOUnlYDldDAtcVv3tvXIykvWTy5V9KDfEDUte9Fa9hg/2/ahtdX3CBTugcONml+CkjcKJbfE+H9uCWpeCUpeCWpBGYqrpxUw3+3kk9Zx7Fy8jFn2GnDlouaXctNTm6n3qPzw7CXYRmVWwCXDTGiIfwEIaZGeXkfNG81bH+1jX7MXf+USciccbK331ydWs8XTxmWzZuGYPjjZTeMq8vlkW3PCTL2aqAKH+wsieAQhio4BuLSsGJ5+9tIyM7SS1QmJZ3RZHu27WtnTkBnBYwYsz51cyvsb6pM+vJO5tMYmucGnSl83WCvtON7C02Q8PPojeIryI3Esu+o6YmJRgiEtJoOpN5dWMGTG8KTf6yu+Bo9JcVTxwVA4oiKVlPR0mFBVgKootHX6aenwxcRlRRp09n0+6pqG1rqHUP02tPpthBq2oTXvAT3JtWCzoxZWohZVohRWoOaXGSKmoBQ1vyxhGncqmC8qbUEXjjlHAUZsWr1nG0CP2k6DSXS/smgxWdvsIRjScDlsTBpdSFlRDo1tXnbWtlv1kALBkJUxOXVs4ho5mR1jrIXTci9DTDXrkY4IHkGIwnSXFPbDwuO0uqX3z6VlCp5EzR4TMaYsnw27WtmbgTie9m4/Te1eFODgqYbgSWThCYY0K86ptCgHLRB5Ux9dloeCIRrbuvx99nyKZ3cfgqcwysITnYUzEJcWwKTqQlo6Gti+L1bw7K7vtIQMROJ0EhHSjGUeXzBtF2MyC09RVC0e02iYaQuPy2FjbEUeu+o62ba33RI8/kDIio2KD6DXg35CjTvRmnaiNe0m1LTLEDehBGLPlYetZAxq8WjUktGoxdWoxVUoeaWDkqacqBZPY5uRoVWQ6+hhwRtMqkvzrAKA0WKyxgrMz0NVFCZWF9LY5mXbvojg2VlrnHuFuY6EWYeZwgxGr6nvirmmzDFWjErsXh6piOARhChMC09Bfyw8jv5naWm6HtPcMBXMwN6axoFnau0IW3eiW0okslaYIsimGkG1ra0RweNy2CgvcVPf4qGmoZOivMTVexMRCGrWA3ZcggwtiLQO0HXo8gQoyHXi8QWtcVb3w8IDRuDyB5sarDdqk/hA5lBvLq0oYdTa6aMyjbHE1+AxiW4v4Q+LrUylpEczZXQRu+o62bq3jUUzKwAjGF7TdfLdDopy7YQathPcs47Qnk8J1W6CUIL2DY4cbOWTsFVMRi2fjK18EkpeScLilYNFfoJqy/XhysjZtO6AkcRQVZrLnoYudtd3WoInXthPri7k/Q311jUIsHlPKwBTxxYP6vxVjXJjt6n4AiEaWj1W2QVrjAmSB0YyIngEIQozaLmwH0HLZpaWrx8urYZWDx5fCLtNTdmEbK6XCQuPGb8zsarAeqi2dfrRND0m88kUFyUFroQ34rHl+dS3eNhT38mcJO0KErGvqYuQpof7+yR+qNttKnk5drq8Qdq7DcFT12KIpMJcR79bR0xKErgcL3iSBS3ruh4jhlo60hQ8Sbqgm+6r1k6fdU6lazVLhO7vJlS3hVDtZkIN2znaa8fjctNYA7o+FUVR2L2ngYOdOziysJ6uJ5/tEUisuAtRyydhGzUOtWw8tlHjUQorhry4XKSfVkSsN7QNjeABQ7ybgsesoxMfqzap2njB2R4luLfUGPV3piZp+ZApbKrKmPI8dtZ2sLuu0xI8plt6fwpYBhE8ghDDQIKWTZdWMKT1KHzWFzut/jR5KffGMi08ze2+hAG36WA+7CdWF1KU50RRDKtTe7c/xqpgxu+UFCQWJWPL8/hgU4PVADRVot96e3ujLch10uUNGnE8ZXmWVaiql0anfWFa1OpbPHR5A+SFhZMZ02TWwwkmieGJt/ykW4vHTEvv6dKK9NPy+EIJ10kH/4Y3Caz7N1pTDUTlL5UAX84DvCvoevofqAXlzK/dwoJ8DUxDicONffRMbGNmYxszG7V4dFYtN6kS6ZgesfCYVZbLixPXaBpMxlXk8+76upi4NvP/poVnfGUBCsZ13NbpozDPyZZwwcHBjN+JHuPO2g5qGjotC58VT5fE2jpSEcEjCGECQc16sPTHpRXdJTwQ1NLyfVsBy2m0icjLcVh1NPY0dvX7bVDXdcuaMamqEFVVKMozttvS4YsRPC19Ch7jBrknTTdbXxlaJoW5DmqbIzEaZt+z/gQsm+S7jTiJ+lYPO2o7mDNxFB5fkH1hy9nEqgK27m234nTiibf8pJOabnazhkRByxFLm91mZmml79LSNQ3fu88Q+ORf1mdKYQW2qmnYKqagdbWy6f2VjFMbsHe1EOpqQQXqQoXYxh/MuIVGMTxFHf6xHIlieKwqy0XZt/CMjQpcBqOYo3kNmdeK22WnuiyPvY1dbN/XQXVpLh3dAew2Na37QX8ZFzfGYEhjbzgRYIxYeARh/8S07thUpV+F1swYHkhf8OxIM0PLZExZnlE4bACCx+wzpSqK1dKhpMBFa6ffsOhEZcSaD/Nkgse0OpkxIKlaueLfepNhClEzuHwgKenRTKwuMATPvnbmTBzFjtoOdKC0MIeSwhzY256yhSed1HSvP4TfclfFzmlhngMFw9LmDxr7KE7TpaUHvHhef4DQrg8BcB5yDo5ZR/eokPuvbZPZtL2erx7mZG6lwm3/bGOvP5+fHHoo9hGUpZMohscUPBUlQ+DSCp/Ptc3d+AMhq5hjWVFOjEV2UlVBWPC00+U1xj6xuiDmJWrQxlgeK3jqWjwEQzoup42youxbxQaToe/mJQjDBDNgOT/XkZY7ysSmqtjC8S7p9NPSdd1Kf06n3xAY1Y2h/6ngEBFbY8rzLJEW6dYd+/COuLQS3wgrS3Jx2FX8Ac160PSFrut9ZmiZWLV4uuMETz8ztEzMeTcDRy2LV3UBpaFGqmytSbO04oVQOqnppnUnx2nrkdllU9UY12quy44zDRGtdbXQ/ffbDbFjs5NzwpW4DjkrYTuAydWFBLDzUWcFzRWL2OvPx2lXBywks01+nIVH03Sa2kyXVvYFT1Gek4JcB7puvAQkO88nheshba9tZ3M4fmfaIMfvmJgvOY1tXrq9wR5ZZPsTYuERhDBWwHI/3FkmDrtKyB9KK1Orsc1LlzeITVXSrnmRicDl7VEByybFYQtOvHumL5eWqiqMLs1jZ10HNfVdSZttRtPW5afDbCnRx/Gb5QI6uo3UdLP3V38ytEKtewluXYXu62KOVswkewd7a0HXNTp2buRM90cc3rYPt7+ZEwtV1ngnAz0busYLoXTaSySrwWNSlO+yygCkGr+j+7oIbF6B/6OX0LtaUHIKcJ/0bWyVU5N+Z8oYswBhu1V/Z2xFftqtOoYa0wLo8QUJhjRaO3yENB27TRmUDLe+UBQlUoG8vpPdSSyZVuD8vg6aw/3LBjtg2SQvx8GoQhfN7T5qGjoj1tb9LH4HRPAIgsVAavCYOO2q4aZIQ/CY8Ttjy/PTNmFnoqfWDsuaEbEulZgWno5Ya0VfLi0w3gx31nWwp6GTQ2aU97l/842yalRunxYMy6XV7ael3Yc/qGFTFcpSDEjVuloIbl1JYMsKtMad1ufFwHfCh9/x++c4NegDNxA+fLuiUdi+FTi4xzbjKzCnE7QcqcGTeD6L8p3srg+PsZcHtq7raHVb8G/4L8Gt71k1cdTiatwnX4NaWNHrOMy/fW1zNxt2tQBGMO1IIzfHjqIYpQs6PQHLylhalH6ftUwR3WIimYVnbHk+NlWh0xOwmtVOyULAsjXG8nya230xY9zfMrRABI8gWAykBo+Jw24DAmkVH+xv/A5ELDxtnX46PQHLpJ8quq5HZWhFWXjye1p4dF3vM0sL0nezperOgkj2XEeX33JnVZS4e23FoWsaod1r8X/6H0K71mJlKCk2bOMOQi2qQmvdS8vubRTShRL04dXtrA+MZfGJJ7Ppg9VMaX+Pgs5dCbffw8LT6evRpiEZyVLSTaIrKycTPHrAi+e1ewntWWd9ppaMxTHrGBzTj0ipanFBrpOKcA2ld9fXATB+BD7wVEUh3+2goztAZ3eAhrahy9AyMc/rHXUdliU2/lx32FXGVeRb12JliXtAlua0x1iZz0dbm9hdH7HwjBULjyDsv0RS0vt/o7GKD6ZRi2enFb+TvuBxu+yUFrpoavext7GL6eOK0/p+Q6uHLm8Qu02JucGZgibaWuHxBS3LVV8WHiDl1HTrjTKFG6z5EOjwBNjXR0sJrbuVwIa3CGx4E72zyfrcVjkN+9TDsE9ZgpoTmfOnX1zPB+t2MbtMY22Dg6ryQo6efihNG1uZ0v4exZ5kgscQUGaNoGBIpzNcGLEvkmVomUS7sYoLeq6jB3x4Xrmb0L6NYHNgn3IYzllHo1ZMSTttfPLoQupbPPj8hlgfiRYewBI8HVEWnqGI3zExxc3WmjZ0jF51ZQnGM6m60BI82UhHj8asuLxxd6vlUhPBIwj7MZGigwNxaZntJVITPLqup91DK54x5fk0tfvY0w/Bs8Oq/1MQU//H6uMUFY9ixu/k5fQePGtaeOpajMyUvtxUyeIaElEQ1TE9WcCy1laL/6OXCWz6v0iTSlcejhlH4Zx5DGpxVcJtT6ou5P8+cfJBQ+R3gHb3WDQdcgMtaN2tPYJ+g+F0dafDhqoqdHQbqcepCZ7ENXhMoq068RYePejD8+qvDbHjcJN72nexVUzpc5/JmFxdyLvrDOuOokQy7kYaBblO9jV1x7i0BrM9Q1+YLSbMbL5kwcCTqgv5z5o9AEwbW5zNIVrXnhkTV1qY069M1eHOkBzRvn37uOOOO1i5ciV+v5958+Zx4403Mm3aNGudE088kZ07d8Z875xzzuHnP/85AC0tLfzkJz/hrbfeQlEUTjvtNK6//nrc7qE7sYWRTUZcWmbH9BSztJravXR6AthUxbKMpMvosjzWbm1iTz8ytbbtDQcsV8eKLdOC0+UNWqLFdG8V92LdAUMsmdaOfU3dvQq5QFCzaumkJHjClpAub9ByD5gWnlDjTvwfvkRw+3tGEAegVkzBOfs47JMXo9h7/7vGW9jMzBndmcveUAlj7S2EajehTl4Ss56ZpWW3KRS4XXR0B2jt9DO+ss/DiXJpJYnhibL8RMf56EE/nld/Q2jvp+DIIffU6wYkdgCmRAXJVpfmjdgeSlYtnm7/sLDwRLeYgIg1JZ5JUdfglCwFLJtUFLtxOlSrRML+1CE9mqwLHr/fzxVXXEFxcTEPPPAAOTk53HvvvVx88cW8+OKLjBo1iu7ubnbv3s2DDz7InDlzrO/m5ET8sFdffTUej4fHHnuM9vZ2brrpJrq7u/nFL36R7UMS9hMiQcsDcGnZ0+untbPWECljyvLC8T/pMyaNTC1NM4oMfrS1kY+2NFnupPiHvdtlt26ArZ0+KkpyIxlafWS7mJkpG3e3UtPQ2avg2dtotJTIy7H36iYzyc9xWEGp28LB1uPsrXS/8hyhXR9Z69nGz8d58GnYq6b3uU2TcRX5MW/ik8MWHrtNYVuwIix4NuOIEzxmDI/dplJc4GJXfWfKgcvJGoeaxFp4jHUssbNnvSF2Trmu1wysVBlXkY/dphIMaSMyfsckuhbPUPXRimdcRX6U4Ek8t9WlecybUoqqKFQPsMxCuqiqwpiyfCtjc6Ra9/oi64Ln/fffZ9OmTbz11ltUVhqvQHfccQeHHnoob7zxBp/73OfYsmULmqaxYMECiop6Kt01a9awatUqXn75ZaZMMd5qfvzjH3P55Zdz7bXXWtsV9l90XUfT9V6DVdMlYuHJhEsrNQvPzjrjBjO+n+4siC321xuNrR5+/vQHlo8eQAFmjC9mwbTYbCpFMdJ461s8tHQYgsd0b/Vl4QFiBE9vRBccTBZzons7CTXuRC0sR8kvtWI0ikMtnJL3EaX/20EIQFGxTzkU5/xTsZWO63OM8TgdNsaU5bGrvhOnPdLTzKYagmcZGwnt29Tje2aWlk2NpD6nWnwwrRiefBe6puF94wEjQNnuwn3KtdiqpiX8brrYbSoTqvLZuqd9xMbvQKQWT12LEZ8GDHkBvXHl+bxLnfX/RKiqwnc+Pz+bw4phXEVE8IiFJ0NMmzaNhx56KEaUqOGHVnu7MdkbN26krKwsodgBQzSVl5dbYgdgyZIlKIrC6tWrOfXUUwfxCIThwPP/2cq/V+9m2fzRnH74xAHX2NB1PRK0PIAGjWZaeaoxPHsbDXfOQN6oq0vzUDAEW3uXP2nj0093tdDc7sPlsDF/ainzppQyd3JpUhdeSVjwmIX0WszGoSnM9ZiK1AKX+0qB1bwddP/tJ+htxsMC1cY1OQU021xMsdejKmF30pTDcC06G7UocXxOqkysLmRXfSfjKyMxTXabyraAcb/Smneh+z0xmU+mhcdmUyOxTylYeDQtcs4lS0svznfitKtouvF/3/89SXDHB2Cz4z75O2lZsFLh3KMm898P93LkvOq+Vx6mmOfzjnAzzoJcx4D6zGWCaAExXK0n0WPcHwOWYQgET3l5OUcffXTMZ0888QRer5cjjjgCMARPbm4uV199NR988AElJSV89rOf5aKLLkJVVerq6qiujr0gnU4nxcXF7Nu3r99jsw9CGW9b+KZpS7EhpJAam/e0EQzpvPHBHt5eu48TFo3jrKMmUUL/5trrj2QgjSp09ftcMKvlhjQ9pW2YgdJlxe5+79NuVykP94KqbelmVJK32U6P8ba7eFYFV5w5J+E60ZSEu5a3d/ux21WrSF5pUU6f57Xpxqqp76S1y9/jDVvXdfY1dbNpd6u1fvzx60E/3a/dY4gdRw5oIQgFKKWV0rARbrttEvM+exn2sp4FAfvD0oOqeOujvRw+t8oaj9Nho03PpcNWREGoDRq3YR8/NzLO8E+7TaU03K+ptdPf59+ztcOHrhsBwiUFroR1Yux2leu+vABXjgPb+lfwrX8DUMg74es4x/f9N0yXuVPLmBvu6j1SMa1iZmPZipLUr63Bul/PmFBCebGbsRV5A3qhGkwmhl24DpvKmIq8jFrPEzEUz8aMC56amhqOP/74pMtXrFjBqFGjrN//9a9/8atf/YpLLrmEGTNmALB582ba29s56aST+OY3v8nq1au54447aGtr49vf/jYejwens+dJ43K58PnS61RsoqoKJSWDp7wLCyWYOqOEnw1lRTk0tnn557s7+e+aGi478yBOOmxi2purDac4Ox02qioK+90JuiAcfGqz21I6n0w32rjqogGdf5PGFFHf6qGlK5B0O76woKsszUtpX9XlBUAd3X6NkpI82j2RsZrnc7Lz+iC3E1UxXDbX3vs/ykvczJlUyuQxRezY186Hmxpobvda68+fURkzJl3XqP/L/YRqN6O6chl98c9wlI0h1N7Ek398k73bt7MnOIoZhyzk+GmzUpqjVDiyJI+l88egqop1DhSE22g0OsdS4GnD3rKdkvmHWd/JcRv3ohyXnXHhh0aHJ/nfwWRPcyS+pLQ0+Rv14SV5dHz0Bg3vPg9A6YmXUrTo2H4e4f5PdVxQ8NiKwrSvrUzfr0uAR//fiRndZqZZXJTLqYdPZHxlAWWl2XNpZvPZmHHBU1lZycsvv5x0ebSb6plnnuG2227jzDPP5Prrr7c+/93vfofP56OgwJj0GTNm0NnZyf3338+3vvUtcnJy8Pt79qvx+Xzk5vYv2EvTdNrbu/v13d6w2VQKC920t3uS9uIR0sfnM6wVl50+m2BI40//3crO2g6efGUDS2dXpj3Xu/ca/WsKcx20tvb/PNDCKcrtHV5aWnp35+i6bj30VU3rc/3eqAhbUDbtbKZlTuIYtnpT1NmUlPblDmec1TZ20tLSRWM448Wh6LS3e/o8ry86eSZvfriXnbUdNLR4+G9LDf/9oMZa7rCpTBtXzOJZFRTl2GLG1P1/z+L7dAWoNnJPvpou+yho9QC5tOVPYoXPMPEszXcOaN5SwR9u5rhHqWYS6+jcvg5lfmSfbaZw03UcYZ3c2Orpc1wbthu1gapLcxOuqwf9aF2taPVb6Hz9dwC4FpyGNvXoQT/mEU3c+ViU50h5vg70+/WXjjOC37NxfmVqrgsL3SlbiTIueBwOR0xsTTLuuOMOHn74Yb7yla9www03xLxRO53OHhac6dOn093dTVtbG1VVVfz73/+OWe73+2ltbaWiovcS6r0RTKMdQLqEQtqgbv9Aw0wFVoA5E0cx6UuFXPXrt2jt8NHZ7ceRppm0pcN4aBXkOgb0d7KH3RJef6jP7XR7g1Y2V16OfUD7LQ0LnqY2b9LtmHElBe7UjtFssdHc7sXrC9LeGSnMaN6gejuvl80fzbL5o/H6g2zd287m3a3sru+kujSP2RNLmDqmyKrRYxTvM/6m/vVv4PvQeGnKOfoylMqZMfuIriZdUewe9OvKvDXtVQw3erBuKwGfH8Vm3D794UJ9qqLE1Any+oIxtY3iqQn3rKouzbOOIbj3U3wr/4je3oDuiw34dk47HMeiz8p9pA9yXbHZjqWFrrTnTO7X2SObcz0kgSWm2Lnhhhu48cYbY8SOruuccMIJ3HfffTHf+fjjjykvL6ekpITFixdTW1sbU6dn1apVABxyyCHZOQghI7R0+Hjo7+vYXNOa1veCVqCoce7k5tith42ZipoOmajBA9Fp6X1naZlF59xpdsFOhJnl01uwrNmEMllQczzR1Zbbu/zoGJlI6Wax5TjtzJk4irOPmsy3PjuPzx0zhdkTR/U4Zl3T8K15Ed87TwDgXHQujmmH99hedNmAgXZJTwVbWMQ26sUornwI+dGaIvces/Cg3Wa0NTDXb+uja/qexkhJAgCttRbPq/egNWyPiB2bA7WwgoKFJ5J73OUoisQC9kWBO/b8Hsqig8LwIutByytXruThhx/mwgsv5IwzzqChocFalpubS15eHp/5zGd45JFHmDx5MgcddBArVqzg4Ycf5qabbgJg/vz5LFy4kGuuuYYf/vCHdHd3c8stt3D22WdLSvoI471P63h3fR2dngDXfvHglL9n1kqxRwXWVZTk0tHdRl1Ld59dt+OJtJXof0o6YD3EU8nSau8jJTkdzCy13h6yVp2hVAWPlWLtt9Ksi/OdCavEDhStvR7Pfx5Cq9sCgGPWMTgXnJFwXfNvpCpKVuqrmFaakA62qmkEd64htG+TVejPbC1hUxXUcDp/U7uXlk6fZXlLhFk3aXRZHrrfg+e1eyDgwVY5DddRF6HmlhgVoh1GPFhLSxeI1aFPnA4Vh121rKdDXYNHGD5kXfC8+OKLgJGZ9cQTT8Qsu+qqq/jWt77FddddR35+PnfddRe1tbWMHTuWm266iS984QuAUSPkvvvu40c/+hEXX3wxLpeLk08+me9///vZPhxhgJgpz9v3tafccBEiFh67LbJ+ZYmbrXvaqGtO38LT3hW2fmTKwpNCL62+arCkg5mZ0t7tR9P0Hhk/wZBmdWFOVfCYqdLBkGbVy0mlBk866LpOYMOb+FY8A0EfOHLIOeJC7NMOT3oulIUzoUaX5fXqMsoUpsUmGNKwVU03BE/tJph/CmCY5AuVbsYFd6J7J1Fc4KSp3RvTliOejm6/ZXGrGpWD978PorXuRcktJucz3+zRvkJIHSXsWmxu92G3KQMuWSHsP2Rd8Nx2223cdtttva5jt9v55je/yTe/+c2k65SWlnLPPfdkenhCljHTsru8QepbPVSWpOaiMGN4ooPVKsMtBupb0g86zkTjUMCqluxLxaXV2XuV3XQozHVaFYjbu/09bvKmy87sJp0KDrtKvttBpydgFSRLpQZPMvSgH62tDq11L1rLXuNn0260tloAbNUzyDnmq6gFvadFj6/M5+tnzbF6dg02pqgKhnSryF+odrMl0Eua13JT8d/IaQnQ+cSf+aJ9NO/mVOJtKEKfUZ5QuJnWnbKiHNR1r+DfsRpUO+4TvyViJwPkuw3BU1bkTpjuLxyY7H/dwYQRhelmAdi+tz1lwRMy4ybUWAsPRBrgpTWODDQOhfS6pbeGY3hStbj0hqoqFOY6aevy09bZU/CY81yQ50jLJVWc7woLng7r977Qgz605hpCjTvRWvagtdaitdWidzYTqVoTPXg7riWfxTH3pJRiVBRFYcms7LmuTStiSNNQyyaCzYnu60Rr2klg/X+YuetNUMCr5pKjdVMZ2MNZuXvg0w/orh2LY87xOKYtRXFE3Fum4Dm0qA7/+38HwHXkhQPuhyUYmP20xJ0lRCOCRxhSogXPtn3tHDYntUq5oV4sPHVDGLScTqVlM+spUyb34nwXbV1+Wjt9TCC2joblPkvz+EoKXNQ0dFp9gJL1uwq17MX/0UtoDTvQWvdazTt74MxFLRmNrXg0akk1avEY1PKJqO7CtMaVTcwCbKGQjmKzY6uYTGjfBrr/8XMIeNGBVz3z8M88hS8fXs5Hb/4H/44PmeGshZYafP97HN+qP+KYfhT2yYvQWvdRtuEDbijcSXVnKwCOWcfinHl08kEIaZEfPs/Li4e2pYQwvBDBIwwpbd1RFp6w26QvNF2PBC1HxfBUhC08LR0+fIFQWt2eLQvPgGN4jH2mlqWVuRgeCLvG6hJnaqUbsGxSUmCsr4UFTKIYnuDuj/H8ezkEIkJTcReilk3ANmocalEVSnE1alElSk5Bv4s6DhVmJqCZjWWrmkZo3wYIeFHchbxXeib/XKtyot2OWlCGd9JR/O6TUuaPz+Ubc9vxr38dva2OwCevEfjkNQAmgnX3tY0/GNfh52f/wPZjpo4pYuX6OmaOLxnqoQjDCBE8wpCh6Tod4WBhMDqHB0Nan4GopnUHiFk33+0gz+2gyxOgodWTcj8YTdfpzEDjUEjPwpNpwWP2cUqUqdXWT/dZvPUpPobH98nreN5+AnQjoNd58KmopRNQcotHnLBJhpWlFT7v7JMX41/7CrbRM8k5+nLqV9QDu63gZnPO6jrBOfdEHAedQKhmHf51/0ar34ZaMoY3djvZ5Cnl3M8ez8SJY4fkuPZnjj9kLEvnVJGbI484IYKcDcKQ0eUJWJYDt8uOxxdkT0OX1YcpGcGoqpzRFh5FUaguy2PL7lbqW1IXPN3eoGUxGnAdHjOGJw3Bk4kYHoCicFuL1q6egsfKQktX8MRZdEyXlq5pNL72KN3vvQSAffoR5Bx1CYptYIJxOBKdpQVgKx1P/iX3W4UHQ5rR2NR0r5pz1BK2tCmKin3cXOzjjP5b7d1+XrjnfwB8c/TIbdI53BGxI8QjVayEIcN0s+Tl2Jk82ojh2BZu8dAbpjgBejS4G11q1N9Jp/igmaHldtktC01/MbO0/IHeXVohTaPDtPBkLIbHtPAkcGl198+aFG/hKS5woQd9dP3z17SHxY5z8efIOfry/VLsQERUB6POO1PsQKRbut2y8Bhz7POH8IRboESzLypDy2w2KwjC4COCRxgyouNKJoWbLm5LIY7HfMAoCj1STqvLTMGTeqZWR4bcWRBdabl3C09HdwAd4xgKUkwT7wtTOLUmcGn1O4YnSvDkuuw4NS+el+4ksPNDFLuTvBOvwrXg9P3GfZWIeJdWPJESCcYc5DjtuMPtDRLFU+0JC550i2MKgjAwRPAIQ0ZblNVhcljwmOnPvWE+YBLF+piCJ51MLUsMDNCdBbGVlvVkmUpE4mwK85wZqxNi1vMx43Wi6X/QckTwjM4P0f3iLwjVbUZx5lJ9/q04py4ZwIhHBqZLKxRK/De1SiREnY+mZSxR8cE9URWWBUHIHiJ4hCEjOq5kUtilta+xK6EbIJro3kXxRCw86bu0MmnhgdhYo3gyHbAMUJwXaS8R/2Dub1p6fq7RG6pE7eRC5W9oTbtQ3IXkn/0DcsbOzMzAhzlmbI5OJFstmmBUawkTU/C0JLDw7G0QwSMIQ4FEdQlDRkdUKnhRnpPSwhya2r3sqO1g1oTk6aSRB0xyC09zu5dAUEspJifdppq9Eb0/f1CzYnriMa0wZqBxJjAtPCFNp9MTsAKw02kroYeCBNb9C629AVQ7qDbOKdzHQfomirVulPxSck/7HvbS0Rkb93AnWliHQjrxhsVIm5PIgkjj1Z7uRculVS6CRxCyiQgeYciIz1KaNLqQpnYv2/e19yp4Qgn6aJkU57vIcdrw+kM0tnmoLu37odKeobYSxphUVEVB03X8AY28JHXPMtk4NHrfZiuItk6/dTxmjJKi0GtbCV0L4f3PgwS3vRfz+VHh53ins5TKM29CzR+VsTGPBKKFdTCk44ybQjOIPqGFJ86l1d7tp9MTQIGUzk1BEDKHuLSEISM+rsSK49nbe+BybxYeRVGsAoSpxvGYgqAwAy4tAIfDrMWTPFOrNYN9tKIxM4Rao+J4omOUksUL6bqG981HDbGj2nDMOwXnwafhmHcym/IW8opnHjvnfeOAEzsQCUaGiDs1mlBvFp44wWO6s0qLctIqjCkIwsARC48wZMQHC0+qNurv9JWpFeolhgeMFhO76jpTjuMx08MzYeEBI47H5w/12k8r0zV4TIryXdQ0dMUUH4z0CUu8L13X8f3vCYKb3wFFJeeEK3FMPMRaPnmOD8/2Zg6Znb3+VcMJVVEsq12iTC3LwmOLtvAYc93U7o1ZVzK0BGHoEAuPMGTEP4gnVBWgKIYbIN4VEE1vWVqA1YA01dT0SFuJzFh4nClUW24PB7Nmqo+WSXF4LqPToXvL0NJ1Hd/K5wh8+h9AIefYK2LEDhjWiiPnVQ+4RtFIxmogmiAQPZHFcWxFPgqwo7aDddubrc/NpqGjJX5HELLOgXsHE4YUXdejHsSG0Mhx2q033x29WHnMh44tmYUn7NJK2cJj1uHJkLXFkUI/rcHI0oLEtXjakqTd6wEvvneeJLD2FQBcyy7BMfWwjI5nf8HM1IouemkSTBBTVlmSy/GHGC0jHn9lAz6/cS6IhUcQhg4RPMKQ4PEFrTfj6Id+KgUI+7TwjDItPH0LnpAWlcGUQZcW9G7hGTzB07PacqIA6eCONXT98QcE1r8OgOvw86Vbdy/Et5eIJtLINvZ8PPfoyZQW5tDY5uWFt7YBURYeETyCkHVE8AhDgvnAd7tsManbZj2e3jqnWz2NkgTgmkHLTe3eXmvhAHR6jJo/Cr1nMKWDVXwwSQyPzx/CG37jz3QMj1XwLqqfVrRLS+tswvPqb/C89hv0rmaUgjLcJ1+D86DPZHQc+xtWe4kEMTzJzsccp52LT54BwL/f382HWxolQ0sQhhAJWhaGhGTVjaMrLmu6jpqgZUEwQWXbaIoLXDjtKv6gRnO7l4pwTE8izIDlPLcjYxWPHVZ7icQuLbMGj9OhkpOhXkq6rqE17qQox3iQRlt42rr8KOhMal9N1x9fgaAPFBvOeSfhPOQsFHtm44j2R+y9uLSSWXgADppcytI5VaxYV8tDf18HQFmxZGgJwlAggkcYEpIV+xtdlofTruLxBalv8VA1qqdYCYV6ZsVEoyoK5SVu9jR0Ud/i6VXw9JXB1B/6cmlFu7My0YMqVL8V7ztPoTVso8pVyLE501jVORNd11EUBVtXPVcVvM7o7fUAqJVTyTnqYmyjxg143wcKvbq0+ogp+/IJ0/hke5MVKzamLH+QRikIQm+I4BGGhGSZQ3abSnG+i/pWD53dAUhQ9sV6o05Qh8ekotgQPHUtHg6K+ry2uRufP8S4inxUVcl4hhaAw2EGLScRPFYNnoFZVrTuVnyrnie46R3rM8XXztm5qzleW0fXah9Oh41LQn/C4Qih25zkHPoFHHOOQ1HEm50OkQaivWVpJRY8+W4H550wnQfDFh6J3xGEoUEEjzAk9Naw03xTDiSJv0mUFRNPJDU9Eri8dW8bv3jqA4IhHbfLzszxxWhh8ZSpGjwQbeFJ5tIaeMCyf/0b+Fb+EQJGnRf79CNxLTqHUM069vz3eUrVDvQP/oQPcCiwMVDNtLO+hbPywGkJkUnMczJdl5bJklkVvL+hntWbGpg5oXhQxigIQu+I4BGGhN5cSY7wgyNZwHFfWVoQCVw2a/F0egI88NdPCIaMuCCPL8iazY3W+ploHGpiCZ4kQcuRPlr9EzyBbe/h+98fAFDLJ5NzxPnYKqYYv89cxsNv2RjbuY4vVGzCHujm2db5rPRP5Xfl1f3anxCpsdNr0HIvAlxRFL5+9hwaWr0J3bSCIAw+IniEIaG3Ynj2sGAIJnEJhfrI0oIowdPqQdN1Hn5xPU3tPipK3Nx80SIaWj18urOFDTtbaGj1sGRW5qoIm1lnSS08nf238GittXjffMTYz0En4lr6pR7uqcJ8N6uap3LwwWcwutTNu49/QGFe8rYSQt9EsrSSu7R6c7GCIZpE7AjC0CGCRxgSenNpmZabYAL3AUS/Ufdt4Wlo9fDyip2s3dqE3aZy5dkHke92kO92MKm6kFMPmzCg40iEM9xLK1lrCcullWYMjx704fn3fRDwYquegeuwLyaMxYmkpgfID89vpmoMHaj0nqXVt4VHEIShRwSPMCT0FsdivU0ns/BYMRPJHzCjCnKw2xSCId0q+nb+Z6YxvrJgQONOBUeKWVrpZIbpuo73f39Aa65BcReSc/w3UNTEqc1m8cHWTp/lqivKy5zL7kAkWZaWpunoYQ3Um4tVEIShR65QYUiIxPD0fBCbD47kQct9x/CoqkJZkdv6femcSpbNz07ArrOP1hKmdas4jU7pgY1vGdlYikLO8d9AzS1Oum5RnmHhaevy9+o6FFInmYUnFNU9vTcXqyAIQ48IHiHreP1BK6C3t6DlRCnAkFqQKER6alWX5nLhSTMyUvMmFUyXViILjxbVQ8wUJn0RatyJ750njG0v/iz20bN6Xb84qr1EW5r7EhJjS9I8NDqIuTeLoyAIQ4+4tISsYz7wjUrDPU/BSFp64hieUIpBoicfOh67TeWzx0xJuJ/BIlJpuafg6fQELCtBKplhetCP940HIRTENn4+zvmn9vmd6AaixQVi4ckEEZdW7DkZ7eKy9XE+CoIwtIjgEbJOe1fvzTr7TEtPMUh0xvgSZowv6e8w+43p0vIHerq02sMZWvluR0oxH75Vz6O17kXJLcZ9zFdTKhhoWXi6fLR3GeInketQSJ1IIH3sOWmKV0VBsuAEYZgjryRC1ukraLevtPRI4cHhefo6e7HwRDK0+ra4BGs+IfDJvwDIOfoylJzUWhKY7iuPL0RDq1F4USw8A8O08ISSWHiG67koCEIEuUqFrNPRnTwlHZK/TZtEWksMzzdqRy8xPKkWHdS9nXj/+7CxvdnHYx83N+X9u102S3Q1tBqVmCUtfWDYk1gdU8kYFARheCCCR8g6fWUORdLSk9XhMZuHDs/TtzeXVipBxGYKut7dilJUheuwL6S1f0VReliQBtq360AnWWuJSB+t4XkuCoIQQa5SIeu09dGhvK+09FAKvbSGkt7q8EQahya3uAS3rCC4bRUoKu5jr0Cxpy9WiqMEjqJAgVtieAaCGSAf79Lqq1O6IAjDBxE8QtZp76N5Zqq9tIbrW3VKMTxJjl3rasFrpqAvPAtbxeR+jSHaolPgdkhA7QCxJWktEXGvDs9zURCECHKVClmnT5eWvS/BM8wtPI7kvbTaOnuP4fGteBr8HtTySTgXnN7vMRRHbV8ClgdOssKDqdaEEgRh6BHBI2SdSB+txG4We5KaJyaRQNHhefpaFp6Ahq7HHkNvFp7grg8JbnsPFJWcoy5J2joiFaJdZiJ4Bk6y1hKhFKp+C4IwPJCrVMg67X3F8KTaLX2YvlWbQcs6PUWbJfbigoj1gA/v/wxXlmPuidjKBtbUNDqGpz9d2YVYIllacRYesyaUuAwFYdgzJIJn9erVzJgxo8e/lStXWuusWLGCc889l/nz53PyySfz0ksvxWzD5/Pxox/9iKVLl7JgwQKuu+46mpubs30oQpoEgiE8PsPVk+xBnCwF2CSVXlpDidlaAmL7aQWCIbq8QaBnHy3f6r+idzah5JfiOuScAY9BLDyZJZKllbi1xHB1rwqCEGFIKi1v3LiR8ePH8/TTT8d8XlRUBMDWrVv52te+xle+8hXuuOMO/vvf/3L99dczatQoli5dCsAPf/hD3n//fe69916cTie33norV199NU8++WTWj0dIHdOlY7cpuF2JT79UKy0P1zo8NlVBUUDXjUyt3PDn0ceeG3XsoaZdBD5+FYCcIy5EcQw8hbw4Ku1dBM/AsScpPBga5iUSBEGIMCSCZ9OmTUydOpXy8vKEyx9//HFmzJjBNddcA8CUKVNYv349Dz/8MEuXLqWuro6//vWvPPDAAyxatAiAu+66i5NPPpk1a9awYMGCrB2LkB5mW4mCXGfSZp599dIa7nV4FEXBabfhC4RiUtNbOyPxO+ax65qG9+3HQNewT1qEfcLBGRlDjIVHig4OGFvSwoPDW3wLghBhyCw8hxxySNLl77//PieccELMZ4cddhg//elP0XWd1atXW5+ZTJo0icrKSt57771+Cx4zdiSTmDfK4fpwzjZdPkPwFOU7k863y2nEwIQ0LeE6ZgyPy2mLWT6c5trpUPEFQmi6bo2xud2oelxW7LY+8370L7T6beDIIW/ZhagZOgeLC1zYVIWQplNSmJPxc3s4zXU2cIUz7zQ99j5hxqTb7eqg3D/gwJvroUTmOnsMxVwPieDZvHkzJSUlnHvuudTV1TF9+nSuueYa5s2bB0BtbS1VVVUx36moqMDj8dDS0kJdXR0lJSW4XK4e69TW1vZrTKqqUFKS178DSoHCQvegbXskEdQbASgrzk063yXFhhNIJ/HfRI9aL9Hy4TDXLqedju4AOW6nNcZ2rxHPM76qkJKSPDy71tGy4lkASo+7gKKxYzM6hnGVBeysbWfGpNJBO7eHw1xng8LCHACUuPuEK8fINMxxOQb1/mGM4cCY6+GAzHX2yOZcZ1zw1NTUcPzxxydd/t///peOjg66u7u5+eabsdlsPPnkk1xwwQW88MILTJ06Fa/Xi9MZa4Y3f/f7/Xg8nh7LAVwuFz6fr1/j1jSd9vbufn23N2w2lcJCN+3tHssycSCzr74DALdTpaWlK+E6Xo/h+vH5ggnXMVs2dHf7YpYPp7k2XRyNTV2Uhd1LO/e2AVCU66Bx5w46/nQHaCEcUw8lNPmopPPRX7712bk0t/twqWR828NprrOB12tYJj3eQMxctncYVjtd0zI+xyYH2lwPJTLX2SNTc11Y6E7ZSpRxwVNZWcnLL7+cdHlFRQXvvfcebrcbh8N4O5o7dy7r16/niSee4Ec/+hEulwu/3x/zPfN3t9tNTk5Oj+VgZG653f1Xi8nSoDNBKKQN6vZHCq0dhiAtcDuTzocZDREIJp4zM4ZH0RP/zYZqrkPNNah5JSiuPKu9hNcXtMZS12II6vJ8hc6X70b3dqCWTcS17NJw8GvimKX+UpLvoiTfJed1BlDCf5pgSI85XlN821Rl0OfhQJnr4YDMdfbI5lxnXPA4HA6mTJnS6zqFhYUxv6uqypQpU6irqwOgurqa+vr6mHXq6+vJzc2loKCAqqoqWltb8fv9MZae+vp6KisrM3QkwmDQVw0eSL2X1nCqwxPctRbPK3eBKw/Xks/jtBnujeig5foWDwo6k7b9Ca25BsVdiPvEq/vVK0vILmbaefybaKTNyfA5FwVBSEzWI7PeeustFixYwO7du63PgsEgGzZsYOrUqQAsWrSIVatWxXzv3XffZeHChaiqyiGHHIKmaVbwMsD27dupq6tj8eLF2TkQoV9E2kokb2ZppqUnM3MOx15a/nBaOb4ufG8/xhcCf2a0rdlqL+HxBdC72zjDvRpX7VpQ7bhPvBo1f9QQjlpIFStLK661hJmlJUGugjD8yXrQ8sKFCykpKeGGG27gBz/4AQ6Hg4ceeojW1lYuueQSAC688ELOOecc7rzzTs455xzefPNNXnnlFR5++GHAcJuddtpp3HzzzfzsZz/D7XZz6623smTJEg4++OBsH5KQBlZrhV5SpXtLS9d0HU0fXsXetLZaQnvWAQrOBafj/+RfVAVq+W7hS7Sv30H31iCBphp+UtJpfSdn2VewVU4dukELaWFTE1t4pLWEIIwcsn6V5ufn89hjj1FWVsZll13GF7/4RVpbW3nyyScpKysDYNq0aSxfvpw333yTs88+m+eff5477rjDKjoIcNttt7F06VKuuuoqLrvsMiZPnsw999yT7cMR0qSvxqHQe+HB6MJvw+Uh4//0vwDYxs3Ftfiz5H3hdna4pmNTdEqaPyG0bwOqvxNNV2hWinEtPQ/H9COGdtBCWkhrCUEY+QxJWvr48eP7FCfLli1j2bJlSZfn5ubyk5/8hJ/85CeZHp4wSARDmtVaoaC3GJ5euqVHfzYcLDx60E9g49sAOGcfC4CaV8K7o87mpY1rOHOan2mzprFij42nVnawcPYYvjZ3zlAOWegH9iStJULSWkIQRgzD4xVZOCDo6DZSe22qQr47eQyP+Tat6wkeMFExFMMhhie47T3wdaHkjcI2br71udOhsilYzZayY3BMP5IdvhIC2CkvlvoeI5FIt/Q4C88wjCcTBCExcpUKWaOtK5ySnutATdJWAmLfloPB+AeMIYBURUEdBm4E/6f/AcAx6xiUqIeemZYeCGdp1bd6AKgQwTMiMUV4j+ahZmsJsfAIwrBHBI+QNdqsXlK9p2FHx+bEp6YHh1FKeqhpN1rdFlBsOGbGul+ddqMVgT8QFjwtYcFTIoJnJGJ1S5fmoYIwYpGrVMgaVoZWfu/NLG2qYhUfTJ4VM/SCJ7D+DQDskxai5hbHLHNaFp4QwZBGU7iPlgiekYnpsop3aZnnpzQPFYThjwgeIWukkqEFRrdxM3C5h4VHGx4xE7rfQ2DLCgAcs47tsdzhMMbnC2g0tXnRdSOup6iPYxeGJ6bAji6LAJGYMrHwCMLwR65SIWtYFp4UHvrmAybpG/UQW3gCW1ZAwItaVIVt9Kwey02XViAYsuJ3yovdKL3ELgnDl2g3a7Rby3KxioVHEIY9IniErNGWooUHouqeBBOX8h/KGjy6rlvuLMfsYxOKGNOl5Q9qkfgdCVgesUQLmujSCMFh5GIVBKF3RPAIWaO908jSSs3CY5byTxK0PIRv1KHdH6E114AjB8f0IxOuY7q0AtGCR+J3RiwxFh6tp0truBTBFAQhOXKVClmjLVyHJxXBY1VbDiZzaQ3NqavrOr41LwJG7I7iyku4npWlFQzRICnpIx5VVTANeaEYC8/QC3BBEFJDBI+QNdrDdXhScWlF+mklCVoeIhdCaN9GIxXdZsc576Sk61lZWgEtEsMjFp4RTaJMraEW4IIgpI5cpUJW8AVCeHxG5/C+6vBA8n5aQ92s0b/mHwA4ZizrkYoejVl40Bfj0sod9PEJg4cVSB/lZg0NsQAXBCF1hqSXlnDgYaakO+wqbpetz/WT9dMKDmHdk1D9NqMruqLinHdKr+s6HcYxNrV5CIZ0bKpCaWHfQk8YvkQ6pkdnaQ2PMgmCIPSNXKVCVmiPSklPJTXbnqx3kdmdeggsPP4PXwLAPvUw1MLyXtd12GPdH6WFOfJQHOHYE1gdQ9JaQhBGDHIHFrJCOinpEGXhCSZ2aWXbhRBq2UNwx2oAnAef1uf6ZgyPiWRojXwiHdMTWXhE8AjCcEcEj5AV0ik6CInfpqN/t2fZWmJZdyYegq1kTJ/rO+yxbjsJWB75mBa6RIUHJWhZEIY/cpUKWaEtjRo8kDxoeSgKvWntDQS3vAukZt0Bo41ENJKSPvKxWdW/ewYti+ARhOGPXKVCVmgP1+BJ1aUVSUuPq8MzBA+YwIY3QdewjZmDrWJySt9xxll4RPCMfMxzLqbwoNThEYQRgwgeIStYFp781DKVkqelm0HL2XnA6LpOYNsqY0wzjkr5e3ZbpOM7SAzP/oBNTW7hkbR0QRj+iOARsoLVKT03zaDlZDE8WbLwaI070dvrwebEPuHglL+nKIrVXgKMxqHCyCYSV5YgaFlcWoIw7JGrVMgKVtBy/kCDlrObFRPYutIYz4T5KI6ctL5rurWK851WXR5h5BLJ0urZWmIo6kIJgpAeIniEQUfX9Zg6PKlgVbUNJq7Dkw0Lj67rBMPuLPvkJWl/36zFIxWW9w/iCw/qui5By4IwgpCrVBh0vP4Q/nA9nZTr8IQfIPG9tLJZh0dr2Ibe2QR2F/bx89P+vlmLRwKW9w9scVbH6OBlieERhOGPCB5h0DHdWTlOG64UXTtm0HIoWS+tLNThCWwNW3cmLECxpybUojFr8UgNnv2D+CytaMGT7bpQgiCkj1ylwqCTbg0eiAQt9+yWnp1S/rquRdxZU9J3ZwFWz7BKETz7BfFZWtFiXCw8gjD8keahwqBj1uBJS/Ak66UVyk4vrVDdFvSuFnC4sY+b269tnHnEJD7Y1MDBU8syPDphKLDiysLnZPS5KXV4BGH4I4JHGHRMC09hijV4IHlaesSlNbgPmKCZnTVxIYrN0a9tzJk0ijmTRmVyWMIQYrWW0GJjeGyqklJDXEEQhhZxaQmDjpWSnmINHohKSw8mrsMzmBYeXdMIbnsfAEc/3VnC/oeVlm5ZeLJbBFMQhIEhgkcYdKxO6SnW4IFo90GchUcb/F5aodqN6J42cOVhGzNn0PYjjCysLK2whWeoGtkKgtA/5EoVBp10a/BAdFp6fAzP4Nc9CYazsxwTF6LYxOsrGMTX4cmG+BYEIXOI4BEGnbZ+CJ5kaemD7UbQtSDB7YY7yz7l0EHZhzAyiW8tEZK2EoIwopArVRh0rD5aGUhLDw2yGyG0+2N0bweKuxDb6FmDsg9hZGK5WU2Xliad0gVhJCGCRxhUtH60lYBe0tIHuTt1YNM7xv6nLkVRpf+VEKGHS0ssPIIwopArVRhUur1BK9ahPxaeZFlagxHDo3s7Ce78EADH9CMzvn1hZGOPc7NGzkWx8AjCSEAEjzComDV48t2OtESKPS4jxsQKFB0EN0Jg60rQgqil47GVjsv49oWRjS1JawnJ0hKEkYFcqcKg0taP+B2IBC33tPAMnhvBdGc5ph+R8W0LI5/41hJSh0cQRhYieIRBpT8ZWhB5iMSnpYcGyaUVat2L1rANFBv2qUszum1h/yC+tUS2qn4LgpAZslpk5IUXXuD73/9+wmWHHnoof/jDHwC4+eabef7552OWjxkzhjfeeAMATdO47777eP755+no6GDx4sXccsstjBsnbojhRn8CliGFtPQMP2SCYeuObdxcVHdhRrct7B/Ed0u3srQkaFkQRgRZFTynnnoqRx11VMxnr7zyCrfffjtf//rXrc82btzI17/+dS644ALrM5stkjGzfPlynn76aX7+859TVVXFHXfcweWXX84//vEPnM70HqzC4NJfl1bSbumhzBd70zVN3FlCn/Tslj64GYOCIGSWrL6a5OTkUF5ebv0LhUL85je/4corr+Twww8HQNd1tmzZwkEHHRSz7qhRRhNGv9/Po48+ytVXX80xxxzDzJkzufvuu6mtreW1117L5uEIKdDW2T8Lj/k2reuRZo0Q+X8mXVqhvevRu1vBlYd9wsEZ266wfxGfpSVBy4IwshjSK/WOO+6goqKCK664wvps165ddHd3M3ny5ITf2bBhA11dXSxdGomzKCwsZPbs2bz33nuDPmYhPdq7wp3S0xY8kbfmYDASxzMYb9WBTf8DwDHl0H53Rhf2f6w6PJo0DxWEkciQNQrauHEjL774Ir/97W9j3FCbNm0C4IknnuCtt95CVVWWLVvGNddcQ0FBAbW1tQBUV1fHbK+iosJa1l9MN0omMf37B6qfv707AMCowpy05jdHiTo1lai6PGHBk+O099hef+Za93sI7vjA2OasowblHNgfORDPa6fTcKuHNB27XcWU4Q67OqjnzYE410OFzHX2GIq5zqjgqamp4fjjj0+6fMWKFZZr6rHHHmPGjBk91t+0aROqqlJRUcEDDzzArl27+OUvf8nmzZt5/PHH8Xg8AD1idVwuF21tbf0eu6oqlJTk9fv7fVFY6B60bQ9nOsKCZ9zoorTmV9d1FMVwaeXl51BSmENI09F04zFTWpqf1GqUzly3f/AOBP04SsdQNmMuiiJv6+lwIJ3XJUXdAOhASUkeTqdx+8x1Owf13mFyIM31UCNznT2yOdcZFTyVlZW8/PLLSZcXFRUB4PV6eeWVV/je977X4wHzjW98g/POO4+SkhIApk+fTnl5OV/4whf4+OOPycnJAYxYHvP/AD6fD7e7/xOnaTrt7d39/n4ybDaVwkI37e2eHhlH+zshTbMKDyqhEC0tXWl9325TCQQ1Gps6IRTCHwxZyzo7PIT8gZj1051rPeCl7a0/GvuafhStrZn/+++vHIjndXe3cS77A8a53BE+t0PB9M/tdDgQ53qokLnOHpma68JCd8pWoowKHofDwZQpU/pc75133iEQCHDKKaf0WKaqqiV2TKZNmwZAbW2t5cqqr69n/Pjx1jr19fXMmDFjIMPvUeQuk4RC2qBufzjS2ulDBxQF3E572sdvtykEguD1hwgGNXy+iOBB15NuL9W59q36K3pXC0pBObZZxx1wf59McCCd1+arWSBoHLM/YJyPqqpkZQ4OpLkeamSus0c253pIHJXvv/8+M2fO7CFsAK6//nouueSSmM8+/vhjAKZOncrMmTPJz89n5cqV1vL29nbWr1/P4sWLB3XcQnpYXdJznaj9qJtjtZeIq2wLYBtgZozWWov/41cByFl6HopdyhkIvRNfh8f8Kd3SBWFkMCSCZ/369cycOTPhspNOOokVK1Zw3333sWvXLt58801+8IMfcPrppzNlyhScTicXXHABd955J6+//jobNmzgmmuuoaqqihNPPDHLRyL0Rn+rLJvECx7zAaMqSr8ElImu63hXPAVaCNu4edgkFV1IgUi39PjmoRLgKggjgSHJ0mpoaGDu3LkJlx1//PH8+te/5qGHHuJ3v/sdBQUFnHHGGXznO9+x1rn66qsJBoPcfPPNeL1eFi9ezCOPPILDISnFwwmzBk+6KekmVin/YGwa8ECLDoZ2fkho98eg2sk5/DwJVBZSwpastYSkpQvCiGBIBE9vgc0Ap5xySsL4HhObzcb3vvc9vve972V6aEIGaQvX4MmYhScDNXj0oB/viqcBcM47CbWoqt/bEg4srPMxXPwyaLm0xMIjCCMBuVKFQcNMSS/op+BxJInhGcgDxv/RP9E7GlDySnAuOKPf2xEOPCIuLdPCkxmLoyAI2UEEjzBoWIInt3+uxvh+WgPto6V1teD/8CUAXId9CcWR08c3BCFCdNCyruvW+SgWHkEYGciVKgwaXV5D8OS7+yl41NiYieAA+2j5P/gbhPzYqqZjn7ykX9sQDlyihXZI062+btJaQhBGBiJ4hEHDtPD0W/DYk8XwpH/aam11BDa8DYBz8WclUFlIm2hLTiikRwUty21UEEYCcqUKg0anx8jSKnAPMGg5aAqe/sdM+Fb/BXQjDd1ePbAClcKBSbQlJ6hpUTFlIp4FYSQggkcYNDo9QQDy+xnD0yNouZ+F3kJNuwluMQpVuhZ/tl9jEYTo8y4U0q26UBK0LAgjAxE8wqAQDGl4fGHB00+XlvlGHQjF1+FJ77T1vfdnQMc+eQm2sgn9GosgKIpiiZ5gSMtI1qAgCNlDrlRhUOjyGPE7igK5rv6VezItPKG4GB57GhaeUN0WQrs+BEXFteicfo1DEEwitXh0y+IoFh5BGBmI4BEGhc6w4MnLcfS7DUTPtHQzKya101bXdXyr/gSAY/qRqMXV/RqHIJhEt5cYSBC9IAjZR65UYVAwBU9/3VmQvJdWqi6t0J51hPZtANWO85Cz+j0OQTAxrTlGllbYxSpBy4IwIhDBIwwKVkp6PwOWYWC9tHRdx/feCwA4Zh+Lml/a73EIgoktqr2E1S1dLDyCMCKQK1UYFDrNooM5mbPwRCrb9i14Qrs/QmvYBjYnzoNP7/cYBCGa6PYSmWpmKwhCdhDBIwwKnRmw8MSnpYdSzNLSdR3f+38xtjHneNTcon6PQRCiiRbh0lpCEEYWcqUKg4IZw1MwgBieSFp6XB2ePt6oAzs+QGvcCXYXzvmn9Hv/ghCP5WaNai0hFh5BGBmI4BEGhUwELUfS0uO7Uyc/bXVdw7vKsO44D/oMqruw3/sXhHhMa47h0upfIUxBEIYGETzCoJCRLK1k3dJ7cSF0bVxJqGkXOHJwzju53/sWhEREsrS0KAuP3EYFYSQgV6owKGQ0LT1ourR6706t6xotbz0HgHPuiSg5+f3etyAkwhZVeDBSh0csPIIwEhDBIwwKmQhatuIlenRLT/yACWxZRaBhN4ozF+fck/q9X0FIRnThQQlaFoSRhVypwqDQkdHCg3F1eBI8YHRNw/OeEbvjmn8yiiuv3/sVhGSY52QgpKHp0lpCEEYSIniEjJOJxqGQoFt6KPkDJrRnHVrrPtScPHLmndjvfQpCb5jnnj+gWZ+JhUcQRgZypQoZp8triB0Fo5dWf4kPWu4tSDS4bRUA+bOPRHHl9nufgtAbpkvL6w9an4mFRxBGBiJ4hIzT2e0HIM/d/8ahEOlRFLTS0hOX8tdDQQI7PjD2Ofvwfu9PEPrCFNu+KAuPZGkJwshArlQh41id0gfgzoKIhScY3y09TkSF9qwHXxeKu4iccbMGtE9B6A3z3PMHQoBhxRyIqBcEIXuI4BEyTiaqLEPyXlrxLoRA2J3lnLIYRbUNaJ+C0Bs2y8ITivldEIThj1ytQsbJRIYWRAUtx9XhiXYh6KEgwR2rjfWnLhnQ/gShL0yx7fOHYn4XBGH4I4JHyDhdGRI8NluyGJ7IQya05xPwe1Byi7FXTR/Q/gShL8yMLMvCI+4sQRgxiOARMk5HBooOQi/d0qPSgANb3zM+m7QIRdKDhUHGsvAETAuPnHOCMFKQq1XIOJmy8PTopaWZMTzG53ooQHCnkZ1lnyLuLGHw6RnDIxYeQRgpiOARMk6mYngsYaMbNXisLC2zgWPNOsudZaucOqB9CUIqmKUSfP7kVb8FQRieyNUqZJzMZWlF3p6DoUizRvOhY2Zn2ScvRlHkVBYGH5vl0grG/C4IwvBHnhJCxslYHZ6o+IhgKNrCo6IH/QR3rAHAMVncWUJ2iC88KG0lBGHkIFerkHHMTukFAwxatqkK5vtzMKhF1eFRDXdWwIOSNwq1csqA9iMIqWJmZUWClsXCIwgjBRE8QkYJaRrd4cahA7XwKIpiBYkGQlpULy1F3FnCkGBaePx+CVoWhJGGPCmEjNLliW4cah/w9hz2cIBySLcsPDZFJ7jrI8BIRxeEbGEKHD38uwQtC8LIQa5WIaOYGVq5OfaMxDfYE1h4nC3bwd+N4srHViHuLCF7xAsccWkJwshBBI+QUcxO6QNNSTeJ7qdlxfDUfQKAbfw8KTYoZJV4F5b00hKEkcOgXq233HILN954Y4/PV6xYwbnnnsv8+fM5+eSTeemll2KW+3w+fvSjH7F06VIWLFjAddddR3Nzc1rbEIaGzrBLa6BVlk3sUe0lrCytvYbgsY8/OCP7EIRUia+sLK0lBGHkMCiCR9M07rrrLp577rkey7Zu3crXvvY1jjrqKF544QU+//nPc/3117NixQprnR/+8If873//49577+Xxxx9n27ZtXH311WltQxgaOj2GhafA7czI9iyXViCErkOp2oHSvg8UG/axczKyD0FIlXiBIxYeQRg5DDyqNI6tW7dy0003sXPnTkaPHt1j+eOPP86MGTO45pprAJgyZQrr16/n4YcfZunSpdTV1fHXv/6VBx54gEWLjIDUu+66i5NPPpk1a9awYMGCPrchDB2RGjyZObXMflrecFbMHEcNALbq6SiuvIzsQxBSJd7CIzE8gjByyPjrybvvvsuUKVN48cUXGTt2bI/l77//fg9Rcthhh7F69Wp0XWf16tXWZyaTJk2isrKS9957L6VtCENHpMpyhiw89jjB4zQEj338/IxsXxDSId7CI1lagjByyLiF5/zzz+91eW1tLVVVVTGfVVRU4PF4aGlpoa6ujpKSElwuV491amtrU9rGqFGj+jV28+GaSUyT94Fi+u7yGjE8BXnOjMynIypLy0WAqfY6AFyTF2CL2/6BNtdDyYE61y6nLeZ3h10dlPtGNAfqXA8FMtfZYyjmOi3BU1NTw/HHH590+YoVK/oUG16vF6cz9u3f/N3v9+PxeHosB3C5XPh8vpS20R9UVaGkZPBcJIWF7kHb9nDCFzQCiyvL8jMyn+4cI/hZsanMcOzFrmg4RlVTNil5s9ADZa6HAwfaXJd0xt5f8nKdg3rfiOZAm+uhROY6e2RzrtMSPJWVlbz88stJlxcVFfW5DZfL1UOUmL+73W5ycnISihafz4fb7U5pG/1B03Ta27v79d3esNlUCgvdtLd7CIWzjPZnmtu8ANjQaGnp6tc2vB+8SHDfRnKP/arlomxu9VjuLHXcvITbPtDmeig5UOe6u8sX83swGOr3eZ4qB+pcDwUy19kjU3NdWOhO2UqUluBxOBxMmTKwQm/V1dXU19fHfFZfX09ubi4FBQVUVVXR2tqK3++PseLU19dTWVmZ0jb6SzA4eCd4KKQN6vaHCx3hOjxup71fx6v7uvCs+jNoITpeuguXcjoAHm+AxY49AKhj5/e67QNlrocDB9xcx4UIKsrg3jeiOeDmegiRuc4e2ZzrrDsqFy1axKpVq2I+e/fdd1m4cCGqqnLIIYegaZoVvAywfft26urqWLx4cUrbEIaOrnDQcn8LDwZ3rgHNCFDWGraxrPNlFDTcnTUUqF68ugNb1fSMjVcQ0iE+K0uClgVh5JD1q/XCCy9k7dq13HnnnWzdupVHH32UV155hcsvvxww3GannXYaN998MytXrmTt2rVce+21LFmyhIMPPjilbQhDQ0jTrKDl/hYeDGwNNwWduBBsdsb5tnBu7nuUd20CYIs2FsWW8Vh7QUiJ+HYp0jxUEEYOWRc806ZNY/ny5bz55pucffbZPP/889xxxx0xaea33XYbS5cu5aqrruKyyy5j8uTJ3HPPPWltQ8g+ZuNQ6F/jUN3bSahmHQCuJZ8n59ivoQPLcjYys+t9ALYqEzIyVkHoDz0sPJLNIwgjhkF9VX7iiScSfr5s2TKWLVuW9Hu5ubn85Cc/4Sc/+UnSdfrahpB9rKKD/WwcGtixGvQQauk41OJq1OJq3i85gYNa/o2DIJoO21URPMLQER8caZfWEoIwYpDXEyFjRKos9zN+Z5tRWNI+eYn12a7SQ/mvdxYA24KV+G25AxylIPQfaS0hCCMXCYYQMkakynL6gkfztBPasx4AR5TgsdtU/tq9iIac8XzcmU9xrjxghKGjR/NQieERhBGDPD2EjNE5gAyt4I4PQNdQyyagFlVanztsKjoKH/vH0abnSe8iYUiJFzjSLV0QRg4ieISMYdbg6Zfg2boSAPvkQ2M+Nx8wvnAvLXnACEOJqiioSuQclKBlQRg5yNUqZAwzSyvdlHStu43Qvg0AOCYvjllm9tKyBI88YIQhJtrKKIJHEEYOcrUKGaPD0z8LT3D7+6DrqOWTUQvLY5aZjRnNArfygBGGmmi3llgcBWHkIE8PIWN0dvcvhie4zSg26JiyuMeyeIEjMTzCUBNdckHOR0EYOYjgETJGp9cUPD273SdD62ohtM+oohydjm4S/0ARl5Yw1ESfk3I+CsLIQa5WIWNELDypVzsI7lwD6KiVU1HzS3ss72HhEReCMMTEWHjkfBSEEYMIHiFjWGnpualbeMxWEvbx8xMud0jdE2GYIRYeQRiZyNUqZISQptEdbhyaauFBXdMI7v0UAPuY2QnXMYOWrd/lASMMMdHnoAQtC8LIQZ4eQkbo8gStTKq8FF1aWuMO8HeDw41aNjHhOvEuA3s/enQJQiaJFjkiwAVh5CBX6yDS1lDP5uXf5p0/3D/UQxl0mtq9ABTlO1NuHBrca7SSsI+eiaLaEq4Tb+ERl5Yw1ES7sSRLSxBGDiJ4BpF9tY2U0ULF7jcIdTQO9XAGlYZWDwDlRe6UvxPaY7izbEncWZAoLV1OWWFosUsdHkEYkcjTYxBRi0ezMVCFDQ3fmpeGejiDSmObYeEpK85JaX096CdUa6SjpyN45AEjDDXi0hKEkYlcrYNIjtPGa555APg+fQutu3VoBzSINKZp4QnVb4VQACW3GLV4dNL14l0G4kIQhhoJWhaEkYkInkHE5bSxJVjJjlAFhAL4174y1EMaNEyXVqoWntAeI37HNnoWipL8oRGfli5v1MJQEyN45HwUhBGDXK2DSI7DBii82n0QAIH1/0H3dg7toAaJhrBLK1ULT3BPuP5OL+4sSBS0LKesMLTEurTEwiMIIwV5egwiOU4jPXt9YAxK6XgI+vB/8toQj6onNfWdeHzBfn9f03Sa0ojh0f3daA3bgd7jd0B6aQnDj9jmoXILFYSRglytg4jDoWLcGhU46FQA/J/8G93fPZTDiuHttXu55dFV/P6fG/q9jdZOHyFNx6YqjCroW/CE9m4EXUcprEzYTiKanjE8csoKQ0u0yJEyCYIwcpCnxyCiKgoup1Ffxlc1zwjO9XfjX/fGEI/MoK65m6f/tRmAPQ39d7WZ8TujCl2oKQRxWvV3+rDugGRpCcMPU4SrioLaS/yZIAjDCxE8g0xOWPB4AzrOg08DIPDxq+hB31AOi2BI46F/rMcXCAHQEW782R/MlPTy4hQztMyA5RQEj01ViH6kyBu1MNSYIlzcq4IwshDBM8i4wnE8Xn8I+9TDUArK0b0dBDa9M6TjevH/drB9XzvOcFBwlyeApul9fCsxVoZWCgHLWncrWsseQME+elaf6yuKElvZVmImhCHGtDJKAL0gjCzkih1kLAuPP4ii2nDOOQGAwKf/Rdf7JzAGypaaNv7xfzsAuOjkGQDoQKe3f1aehlbTwpNC/E7YuqOWjkfJyU9p+w67FHoThg/mOSjuVUEYWcjTY5AxBY/Pb7iOHNOPAJsdrWmXlamUTTy+IA/9Yx26DofNqeTwg6rJyzGsUJ39dGs1tqVu4Qla7ST6tu6Y2KV3kTCMMN2qci4KwshCBM8gE7HwGIJHycnHPmkxAIFP/5P18Tz/3600tnkpLXRxwWcM606+2wFAR7e/X9tMta2EruuE0ghYNpFCb8JwwrTsiLVREEYWcsUOMpEYnkidG8fs4wAIbF2J7uvK6ng+2mI0MT3/xBnkhi07BblOoH+By4GgRmuHEYDdV9FBrWknemcT2BzYqmakvA9p1igMJ8SlJQgjExE8g4w7zsIDYKuciloyBoJ+AptXZHU8XeE4ndGludZnBbmGhafTk77gaWr3ogMuh83aTjKC294DwD5+PorDlfI+Yl1acsoKQ0skS0vORUEYScgVO8i44mJ4wMg8csw6Bshu8HIwpOEPaADk5kTEyUBcWo1RPbR664ml6zoBU/BMXpzWPhwSwyMMI6wsLbHwCMKIQgTPIGP00wKPP7Z1g2Pa4WBzorXUoNVtycpYur2RMeS67Nb/B+LSakixS7rWtBO9vR5sTuzj56e1D5vE8AjDCFN0y7koCCMLuWIHmZywsIi28AAorjzsUw4FwJ+l4GXTneV22WIqIg/EpWU2DS0r6j1gOeLOmofiSK2juonDJs0aheGDTQoPCsKIRATPIBOptBzqscw5+xgAgttWZaWLumnhyXXFxtpkxqWV3MKj6zqBrauA9N1ZENsxXdwIwlAjLi1BGJmI4BlkXGGXltfXU/Co5ZNRS8dBKEhg8+BXXu4Od0Q36+6YDMilZbaV6MXCozXtRO9o6Jc7CyRoWRheTKouxO2yMWtCyVAPRRCENJCnxyBjurS8cTE8YAYvHwuA/6N/orXVDupYTJdWbg/BE7bw9MOlZVp4euujNRB3FojgEYYXo8vyuPfbyzjjiElDPRRBENJAnh6DjBm07Evg0gIjeFktqkLvbqX777cTaq4ZtLFYLq2cWJdWgeXSCqSVMebxBekKbzNZ0cFYd9aStMcMUodHGH6och4KwohDBM8gY8XwJHBpASiOHNxnfB911Dh0Txvd/7idUMOOQRlLRPAkdmkFQ1pMvaC+MDO08t0Ocpz2hOsM1J0F8WnpcsoKgiAI6SNPj0HGcmklsfAAqLlF5J5+A2r5ZPB10f3iLwjWbsr4WCJBy7HixOW0WV3T08nUSqVpaNC07oyfl1axwWhigpYlM0YQBEHoB4MqeG655RZuvPHGHp//+c9/5owzzuDggw/mxBNP5KGHHiIUigiCv//978yYMaPHv5qaiLvnn//8J6eeeirz5s3j7LPPZsWK7FYsThXTpZUohicaJSef3NO+h616BgQ8eF6+k8CWdzM6FjOGJz5oGSA/N+LWSpW+mobGFhvsnzsLwK4ap6mqKKi9FDcUBEEQhGQMiuDRNI277rqL5557rseyv//979x6661ccMEF/P3vf+c73/kODz74IPfff7+1zsaNG1myZAn/+9//Yv5VV1cD8O677/K9732PL33pS/zlL39h6dKlXHHFFWzdunUwDmdAmJWW/QENTes9PkZxunGfci22cXMh6Mf7xgN43ngwY/22zCyt+BgegAK3mamVemp6Y2vvTUMz4c4CsNulO7UgCIIwMDIueLZu3cp5553H888/z+jRo3ssf+aZZzj77LP54he/yPjx4zn11FO59NJL+dOf/mSts2nTJmbMmEF5eXnMP5vNEA+/+93vOOGEE7jooouYMmUKN9xwA3PmzOHxxx/P9OEMmByXzfp/ssDlaBS7C/dJ38a58CxQFIJbVtD151sI7t0w4LEki+GBqEytNCw8DW29Z2gFNhmp9gNxZ0FUs0aJ3xEEQRD6ScafIO+++y5TpkzhxRdfZOzYsT2Wf/e73+Wyyy6LHYSq0tbWZv2+ceNGpkyZknD7mqbxwQcfsHTp0pjPDz30UN57770MHEFmcdhUK6Mj1YBgRbXjWnQOuWfehFJQjt7ZhOfFX+B99zn0YPrFAU1MwdObSyudGJ5GqwZPT8GjezsJbHgLAMfMZWmPNRqHVLYVBEEQBkji1JoBcP755/e6/JBDDon5vaOjg2eeeYajjjoKgLa2Nurq6nj//fd5+umnaWlpYd68eXzve99j0qRJtLe3093dTVVVVcx2KioqqK0dWB2b6ODYTGGzqbidNrq8QYKaltY+7GOm4/ziT+h+52n8n75JYO0/Ce3+iLzjvoq9MrEg7A3TpVWQ5+wxjqI8w6XV5Q2kNEZd160aPFWluT2+4/n0DQj6sJWNxzVxfq+NRfvCEY6DstvUXsdmE0tQ1pC5zh4y19lD5jp7DMVcpyV4ampqOP7445MuX7FiBaNGjUp5e11dXVx55ZX4fD6uv/56ADZv3gwYD9Tbb78dr9fL/fffz3nnncc//vEPgkHjoe10OmO25XK58Pl86RxODKqqUFKS1+/v94bbZafLG8TpcvZjH3mMOvdqujYeRuM/HyTUspeOF26jeOlZlBz1RRR7z3icZJiCp7qisMc4KkrzAfAF9ZTG2NLuxR/UUBSYMqEUR5QQ0fxe2j75FwClR32O/FH5KY8xEYUFRoyQ02FLaWyFhb03MhUyh8x19pC5zh4y19kjm3OdluCprKzk5ZdfTrq8qKgo5W01NDTwta99jZqaGh555BHL/bVo0SJWrFhBSUmJZRW47777OOaYY3jhhRf4/Oc/D4DfH+va8fl8uN39nzhN02lv7+7395Nhs6lWanpDUyel+akLlBgq5pD/xZ/ieftJ/JtX0Pp/f6H901XkHXsZ9qqpfX5d03W6w+6qoD9AS0tsILRdMQKqm1q7eyxLxOaaVgBKClx0dnhilnnXvobm6UAtrMBfOTel7fVGwG+MW4Fet2WzqRQWumlv9xAKaQPap9A7MtfZQ+Y6e8hcZ49MzXVhoTtlK1FagsfhcCSNrUmHrVu3cvnll6NpGk899RTTpk2LWR5vJXK73YwdO5a6ujqKi4vJzc2lvr4+Zp36+noqKysHNK5gcHBOcFPwdHoCA9uHPQ/XsV9DnbQI39uPo7XsoeOF23DMPhbX4s+iuJJbP7q9AcwcMZdd7TEOs6Foe5c/pTHWNRnisKzIHbO+rgXxrjFEsWPeKYQ0BbSBzauZim6zKSmNLRTSBu1vKcQic509ZK6zh8x19sjmXGfdUbl7924uvvhi3G43zz77bA+x89xzz3HooYfS3R2xtnR2drJjxw6mTp2KoigsXLiQVatWxXxv5cqVLFq0KCvHkC5moT9fGlWMe8Mx8RDyPv8z7NOPBHQC69+g648/ILB1ZdLWEGYLCIddxWGPZI7pQT/+DW9SEjQEZKpZWlbT0LiU9OCWd9G7mlHchTimH5HuoSXEDFY26/EIgiAIQrpk/Qnygx/8AL/fz1133YXdbqehocH6B7Bs2TI0TeP6669n8+bNfPzxx3zrW99i1KhRnHvuuQB85Stf4aWXXuL3v/89W7du5Ze//CWffvopF198cbYPJyXMtguppKWnipKTj/uYy3GffgNKURW6pw3v6/fjefU36MGesUyJUtKD+zbS9ef/h++t31P2f7/iDPdqPB5Pj+8mwmoaGpWhpesa/g/D1p25J6HYnQm/my52ydISBEEQBkjGs7R6o66uzrLMnHXWWT2Wb9y4kerqah577DF+9atf8eUvfxld1zniiCP4wx/+gMtl1HI58sgj+dnPfsby5cu5++67mTp1Kg888EBG3G2DgVmLx+vrvdpyf7CPnkXe527D/+FL+Ne8SGjXh3j+9VvcJ12Nokb+vN1WlWUHesCLb9XzBNa9bix05KAEvJzgXse80C58NdW4xs7qdb+tnUYMVUlBpL5OcOeHaK17weHGOfvYjB3juIp87DaVidWFGdumIAiCcGAxqILniSeeiPm9srKSjRs39vm9OXPm8Oijj/a6ztlnn83ZZ589kOFlDXcK/bQGgmJz4DrkbGxjZuN56U5Cu9fi/c/D5Bx7BUrYDWS6tGba99D1p+fROxoBcMxYhuuwLxLYt5G6V35Hha0D/8u/QJ91LK6lX05qpWnvMgRPYTidXdc0/B++CIBzznEoztyMHV91aR73fvsonA5xaQmCIAj9Q54gWcCd4RieZNirpuP+zFWg2AhufRffO09YMT2h1r1ckf86Z/n/jt7RiJJfivvU75Jz9KUorjycExdyr/9zvOM1YqoCn/4H7+v3o2uJrVLt3RHBo4cCeF9fjla/DWwOHAd9JuPH5nLaBlTLRxAEQTiwyapL60DFjOFJtdLyQLCPn0fOcVfgff0BAp/+B+xO0DVmfvI6qlNDQ8U19zO4Fp2D4ogNOHbm5vPHxqVMX3oM5Wt/T3DnGrz/fYScY7+KokS0sa7rEQuPQ8Pzyt2E9qwH1UbOsVeg5hYP+nEKgiAIQjqIhScLWC6tLAgeAMeUQ3EdeREAgY9fJfDJv1DR+Ng/lv+M+So5S7/cQ+wAFLiN1PSGvKm4T/imYSnasgLfO0/GZH91+4KENJ08xYvrrd8YYsfuwn3ytTgmL87KMQqCIAhCOojgyQLucNByJrO0+sI5+1icS74AgFoylncqv8TDncehFySvVRTdT8s+YQE5x34VUAisfwP/qucB0LUQHbW7mefYxXeKXkVv3I7iyif39Buwj50z6MclCIIgCP1BXFpZIMey8GQ+S6s3XAefimP6ESg5Bex88VOgLmHjUJOCXCMAuSMcn+OYepiR0fX2Y/g/epnAjg/QOxvJCwW5rMD4jpI3Cvep38VWMnqwD0cQBEEQ+o0IniyQraDlRKi5RruPrnBaem5O8tYWpksruvigc9Yx4PfgW/kcepvRnFVTHezxF9DhqmLxWZeh5pcO0ugFQRAEITOI4MkCbufgpqWngidB4cF4TJdWhye22rJz/imoZRMg6EctGcMbG7t5+vWtLJpRzqEidgRBEIQRgAieLBApPDh0gsesw9O7Syscw9Pt77HMPma29f92z1YgUoNHEARBEIY7ErScBSyX1hBaeLpTcWlZMTy999OyUtJzRfAIgiAIIwMRPFkgJ8tp6fHouk53uK2F2cg0EZEYnp4WnmjauwxBJBYeQRAEYaQggicLmBaeYEgjGNKyvn9/UCMYMuro9BbDY1p4Oj1BtCRd1yG2yrIgCIIgjARE8GQBs9IyDI1by+yUrioKOU5b0vXywxYeTdet7yQivo+WIAiCIAx3RPBkAYddxW4z+kANRWp6JH7H3ms/KoddtQRRMrdWTFsJETyCIAjCCEEET5Zwha08niEQPF0ppKSbFERVW06E1x/CHzTcckUStCwIgiCMEETwZAl32HIyNBaevlPSTfrK1DLjd1wOG65e3GOCIAiCMJwQwZMlXJbgyW57CYBuX9il1UuGlkl+H5laEXdW8vR2QRAEQRhuiODJEmZszFCkpkdcWn2LlL5cWlKDRxAEQRiJiODJEjlD2F4ioy4tCVgWBEEQRiAieLJEzjCI4XGnInj6cml1S9FBQRAEYeQhgidLuBxD59Iy09LzUnBpJWsgaiIuLUEQBGEkIs1Ds0SkvUT6QcuBoMZD/1hHtzfI4pkVLJpZYQUXp0J6aeni0hIEQRD2P0TwZAnLpdWPGJ6XVuxg9cYGAD7d2cJT/9rE3MmlHDq7kjmTRvUpflLpo2ViurQSdUwHaAt/XiSCRxAEQRhBiODJEjn9dGnV1Hfy0oqdACybP5rt+9rZXd/Jh1sa+XBLIwCjy/KYPq6Y6WOLmD1pVA93UzourYJUXVoieARBEIQRhAieLJHjSj9oWdN0fv/PDYQ0nQXTyrj45BkoisKehk5WflrH6o0N7GvqZm9jF3sbu/jvmj3k5dj55TcOtxqWQv9cWv6Ahi8QsmKPTETwCIIgCCMRETxZwuUwY3hSFzz/fn832/e143bZueDEGVYfrDHl+Zxbns+5y6bQ3u1n8+42Nte08vbavXR5g+yo7WDWhBJrO5ZLKwXBk+O0YVMVQppOR7cfV5HbWuYPhKzxF+ZK4UFBEARh5CBZWlkiUngwtaDl+lYPL7y1DYAvHDuFkgJXwvUKc50cMqOcLx0/jdkTRwGws7bDWh4MaZZVKRWXlqIoSYsPmtYdu02JsSAJgiAIwnBHBE+WsFxaKQQt67rO4//cgD+oMXN8Mcvmj05pHxMqCwDYVRcRPKZ1B8DtSq33VbJMregaPL11XRcEQRCE4YYIniyRTtDyinW1fLqzBYdd5eJTZqYsLiZUGYJnZ5Tg8YTjdwxXVWp/7lFha1Jtc3fM51KDRxAEQRipiODJEi5n6jE8H25pAuCkJeOoLMlNeR/jwxae2qZuy3XWlUZbCZNJ1YUAbN/XHvO52SldApYFQRCEkYYInizhTiNLy6yBM7osL619FOU5KSlwoQO76zuBSEp6Ko1DTSaNDguevbGCp00ytARBEIQRigieLGGmd/sCIXRd73VdM1i4wJ2+sDDjeMzA5f/f3p3HRVXvjx9/zcCwLwIqoGgqiriwKgiKmtZVr5ne1LoZet1Ky2t1ta7LjzRzKVNzTTN3TS2LyCVN0+pb2UUD1wxcECVIgVyQUGSZOb8/aEYnkX1mhN7Px4NHzDlnznzOe06eN59V34enMjU8zf5oGsu6ns/N23f68eibtGTSQSGEELWNJDxmol8tXatTKNbqyjxWP+lfZZaP0Gvq6QTcSXj0TVqVGVXl7GBDg3p2AFy8fKc/kPThEUIIUVtJwmMm+mHpUHY/HkVRyPtjNJRzFea6+XPH5crMsnw3fT+e1Lv68egTHmdHmYNHCCFE7SIJj5mo1SpsrEvCXVY/ntuFWrS6kiavqtTw6Ju0Ll25RWGRlluVmGX5bi3+SHgu3p3w6NfRkhoeIYQQtYwkPGZka1P+0HR9c5atxgobTcXmzbmbm7MtLg4adIpCxm83K7WsxN2a6Wt4LuUa+hzJshJCCCFqK0l4zMgw23IZkw/qm7OqUrsDJTMlN72rWetOp+XKne8hT2fUKhU3bhZy/fcCirU6Q/IkCY8QQojaxqQJz/Tp05kyZco920eOHEnr1q2NfoYNG2bYX1BQwBtvvEFkZCQhISG88sorXLt2zegc8fHxDBw4kKCgIPr06cPu3btNeSk1Qr+eVllNWnn5JbUoTtVYq+rukVp3hqVXrobH1saKxg1KhsVfuPy7YdZltUqFYxWTMSGEEMJSTJLw6HQ6Fi5cyLZt20rdf+bMGWbMmMHBgwcNP8uWLTPs1+9btmwZGzduJDU1lZdeesmw//z584wdO5auXbsSFxfHk08+yaRJk4iPjzfF5dSYiqynpU8snKuRVBgSnqzf7zRpVWHtq+beJee5cDnXqMOyWpaVEEIIUcvU+AqQ58+fJyYmhrS0NBo1uncNqKtXr3L16lWCgoJo0KDBPfuzsrLYvn07K1eupGPHjgAsXLiQPn36cOzYMUJCQti4cSOtW7dmwoQJAPj6+pKUlMSaNWuIjIys6UuqMXYV6MOjn4OnWjU8fzRp/fpbnqH5qbJNWlAyUuu7E5e5cDkXvyb1AOmwLIQQonaq8RqeQ4cO4evry+eff46Pj889+8+cOYNKpaJ58+alvv/IkSMAREREGLY1b94cT09PEhISAEhMTLwnsYmIiODIkSPlTupnSfpOy2UtIJpXjTl49Oq72uFga02xVuFabgFQ+SYtuDM0/WJmLjfySs4j/XeEEELURjVewxMdHV3m/rNnz+Ls7MzMmTP54YcfcHBwoE+fPowbNw4bGxuysrJwc3PD1tbW6H0NGzYkMzMTgMzMTLy8vO7Zn5+fz/Xr13F3d69S2a2ta76Fz8pKbfivfvK/wmLdfT9L3wTl6mhTrfI083Ym6eJ1w2uXKpzvIW9nbKzV5BdoSfn1Rkm5nKpXLlO6O9bCtCTW5iOxNh+JtflYItaVSngyMjJ45JFH7rs/Pj6+3GTj7NmzFBQUEBgYyMiRI0lOTmbevHlcunSJefPmkZ+fj43NvbUItra2FBSU1DLcvn37nmP0rwsLCytzSQZqtQo3t8qtXVUZLi721HMumb1YpVbf97MKiktmYfas71St8rRu5mGU8DT2dq3SMHdfn3okX7zGydSSBU0belSvXObg4mJv6SL8ZUiszUdibT4Sa/MxZ6wrlfB4enqyZ8+e++53dXUt9xwzZ85k8uTJhmP9/PzQaDRMmDCBSZMmYWdnV2rSUlBQgL19SWBsbW3vOUb/Wn9MZel0Crm5t6r03rJYWalxcbEnNzcf/mhuy8nN5/r1m6Uefy0nHwA1yn2PqQivP5aGANBYq7mZd5uqnK2ppxPJF69xI68kvrZWqmqVy5TujrW2nOU7RPVIrM1HYm0+EmvzqalYu7jYV7iWqFIJj0ajwdfXt0qFMnygtfU9iVGrVq2AO01VOTk5FBYWGtXiZGdn4+npCYC3tzfZ2dlG58jOzsbBwQFnZ+cql6242HQ3uFarQ/NHU9Ct28X3/Sz9bMYONtbVKo9Pgzu1MA62VT9XM0/jeDrZV69c5qDV6h74MtYVEmvzkVibj8TafMwZa7M3VA4bNoypU6cabfvpp5/QaDQ0a9aMDh06oNPpDJ2XAS5cuEBWVhZhYWEAdOzYkR9//NHoHIcOHSI0NBS1+sFte7WrTKflaozSAvB0dzB0kq5Kh2U9/dB0Pem0LIQQojYye3bQu3dvduzYwYcffkh6ejp79uxh3rx5jB49GicnJzw9PXnsscd47bXXOHz4MCdPnmTixImEh4cTHBwMlCRNJ0+eZMGCBZw/f55169axd+9enn32WXNfTqXYacoelq5TFEPCU515eKBkgsCHGpasnF6VIel6DerZ43hXwiQrpQshhKiNanyUVnmGDh2KSqXigw8+4M0336RBgwaMGDGCMWPGGI6ZNWsWb775JuPHjwegW7duvPbaa4b9rVq1YsWKFcyfP5+NGzfi4+PD/PnzH+g5eKD8tbRu3S7Wd/OpkdmMm3o5czbjRrVqeFQqFc0buXAqtWSma1ep4RFCCFELmTTh+eCDD0rdHh0dXebwdQcHB2bPns3s2bPve0y3bt3o1q1btctoTnY2ZS8toa/dsbe1xroGhuoF+npwIDGDZl5V79cE0NyrJOFRUf2mNiGE+eh0OrTa+8/sLozpdCpu37aisLAArfbBndOtLqhorK2srGusq4rZa3j+yspbPDSvBpaVuFv75h4sfjEK52omKc0blUxA6GivweoB7iMlhCihKAq5udfIz8+zdFFqnStX1Oh00mHZHCoaa3t7J1xc3FFVc1kjSXjMyFZT9lpav9fAwqF/VhOdjNs+5Eb7Fu74+dSrfoGEECanT3acnNywsbGt9oPir8TKSiW1O2ZSXqwVRaGwsIC8vJI55VxdPar1eZLwmJGd7R+jtO7TpKVfOLQ6y0qYgo3GiolPBVu6GEKICtDptIZkx8nJxdLFqXWsrdUyJN1MKhJrG5uSVRfy8q7j7OxWreYtaZ8wI/0orYJCbalrftXUCC0hxF+XVlvyB5X+QSFEbae/l6vbH00SHjPSj9JSgMKie7NafR8e6RgshKguacYSdUVN3cuS8JiRjcYK/ddWWsdlQx8eqeERQgghapQkPGakVqmw0c+2XErHZcMoLZncTwghhKhRkvCYWVmzLRuWlZAaHiGEqFXGjx/DnDkzLF0MUQZJeMzMrozZln+XhEcIIYQwCUl4zMy2jAVE7zRpScIjhBBC1CSZh8fM9MtL3LxdZLS9WKvjVkFJvx6p4RFC1DRFUUodHWoONhp1lUbaREV1ZOTI59izZxfFxUW8++5qvLy8Wb36Pb788gtu3syjeXNfnn32ecLDIzh/PoXhw59m7drNtG7tD8DUqa9y9GgCe/Z8jZWVFTqdjv79e/HiixPp3bsvu3ZtJzb2I9LT01GrVbRu7c+LL07E378tAIMHP87DDz/CoUM/cP36NWbPnke7dgGsXLmML7/cS1FRIQMGDLpnqpGtWz9g+/ZYfvstm/r1G/DYY/0ZPny0jJ6zIEl4zKxBPTvOpkP2tXyj7TdvlyQ7Kqq3urkQQvyZoii8tfkoKb/esMjnt/RxZWp0aJUe9p999gkLFiyluFhLkyZNmTEjhrS0C0yfPosGDRryww/fMWnSf3jzzQV07hyFt3cjEhIO0bq1P1qtlmPHErl16xZnz56mTZt2JCX9zO+//05kZBTffvsNixbNY/Lk1wgKCuHKlSssWTKfuXNns2HDVkMZ4uI+5u23F+Hs7EyLFi1ZvHg+P/zwPTExr+Pp6c2mTes4ceIYjRo1BuDgwe/44IP1zJz5Jk2aNOPnn08ye/breHs3onfvvjUWV1E5kvCYWaP6jgBcunrTaHverZIh6Y72GtRq+QtACFHDauk/K7179zXUtmRkpHPgwD7Wr99Cq1atAXj66aGkpJxj69ZNdO4cRZcuXUlIOMzQoSNITv4Za2sN7dsHcPRoIm3atCM+/iBBQSG4uLjg6urKlCnT6NXr7wB4eXnz+OP/YMGCuUZliIjoQlhYJwBu3brJF198ziuvTCYyMgqAqVOnc/RoouH4S5cysLHR4OXVCC8vL7y8vKhfvyGenl4mj5e4P0l4zKyRxx8Jz5U/JTzSYVkIYSIqlYqp0aG1rkkLwMenqeH3s2fPADBu3LNGxxQXF+Pk5AxAly5d2bnzMwoKbpOQcJgOHTri5dWII0cSiY4eTnz8Qfr06QdAcHAoFy9eYMOGNaSlXSQj4xfOn0+5Z0FLH58mht9/+SWNoqIi/P3bGbbZ2tri59fa8LpXr77s3r2TIUMG0qxZC8LCOvHww4/g5SUJjyVJwmNm+hqezGu30Op0htXHf5dZloUQJqRSqQyDJmoTW9s7S2QoSkkisnz5ahwcHI2O06+xFBLSEY1Gw7FjR0lM/JHevfvi7e1NXNzHZGZe5ty5s8yZ0x2AL7/cy5w5r9Or199p3z6QAQMGcvFi6j01PHeXQV9Vpi+LnrX1ncdpvXr1WL9+K6dOnSQh4TCHD8fzyScfMnr0WEaOfK56ARFVJqO0zMzD1Q4bazXFWoXfcm4btss6WkIIUbbmzX0BuHr1Cj4+TQw/u3fvZM+eXUBJ4hEeHsnBg9+SlHSKDh3CCAwMRqvVsnbt+7Ro0RJv70YAbNmygccf/wcxMTMYNOgpgoND+fXXDIBS1zsEaNr0IWxsbDl58oRhW3FxMefOnTW8/vLLL/jss1gCA4MZPXosq1aVfM5XX31pkriIipGEx8zUKhXepTRryRw8QghRthYtfOncuSvz57/FwYPf8euvGWzZspHNmzfQuLGP4bioqG7s2bOL+vUb0LixD7a2drRvH8i+fXvo2rW74biGDT356acTnDlzml9/zWDbti3Exm4DoLCwsNQyODg4MHjwU6xb9z7ffvs1aWkXWbDgLa5c+c1wTGFhAcuXL2Hv3t1cvnyJEyeOc+zYUdq3DzRRZERFSJOWBTSq70Ba1u9cunKTUL8GgCwcKoQQFTFz5lusWrWc+fPf5Pffc2nUyIcpU6bx97/3MxwTGdkFrVZLaGhHw7aOHcM5ejSRqKg7Cc+ECZOYN28O48ePwcZGQ8uWfkyfPpNp06Zy+nQSQUEhpZZh7Njx2NjYsnDh29y6dYuePf9Gly7dDPv79fsHN27cYMOGNWRnZ+Hs7MzDDz/CCy+8ZIKIiIpSKfert/uL0Wp1XLt2s/wDK8naWo2bmyPXr9+kuLikzXd3/EU+/TaVyHaePPd4Sce31bt+Jv7nLJ7q0ZI+nZqWdUpxH6XFWpiGxNp8KhvroqJCrl69jIeHNxqNrMtXWdbWarmnzaSisS7rnnZ3d8TKqmKNVdKkZQF3RmrdMmyTJi0hhBDCdCThsQDvP0ZqXb56E90fFWzSpCWEEEKYjiQ8FtCgnh3WVioKi3VcvVEyUktGaQkhhBCmIwmPBVip1Xi5OwB3RmoZmrSkhkcIIYSocZLwWMjdS0wUFWspKCxZPV1qeIQQQoiaJwmPhdy9xERefsnCoVZqFfa2MlOAEEIIUdMk4bEQQw3PlVv8/sfCoU72miqvNyOEEEKI+5OEx0K872rSkv47QgghhGlJwmMhnm72WKlVFBRqSc/KA6T/jhBCCGEqkvBYiLWVmoZu9gCcTc8BZNJBIYR40BUXF7Nt2xbD67Vr32fw4Mdr/HNMdV5LeFCuRRIeC9J3XD6XkQOAk4NMAy+EEA+y/fv3smzZIksXQ1SBJDwWpO/Hc/N2ySgtqeERQogHmyw/WXvJGGgLalTfwei19OERQpiKoihQXGiZD7e2qdII1Pj4H1izZiUXL6Zib+9AZGQXXnxxIi4uLhw9msiECf9m5sy5rFy5jKysLNq3DyAmZgYffvgBe/fuxtpaw5NPPs3w4aMN5/zii8/56KMtpKf/gru7O/36DWDYsJFYWVkBkJWVyfLly0hM/JFbt24SGBjMuHEv07JlK/bs2cWbb74BQFRUR5YuXWk47+bNG/j004+5ceMG7dq1Z9KkGJo0KVkIOi8vj+XLl/D9999QVFRE69ZtGDfuJfz92xrev2NHHFu3buK3334jLCwcb+9GZcZm/PgxNGnyECkpZ0lPT2PixMn06vV3du/eydatm7h8+TLe3t4MGDCIwYP/CUD//r0ZOnQ4Tz89FICPP/6QpUvfYc2aTYayxMT8F2dnF6ZMmcaJE8dYu/Z9Tp9OpqiokEaNGvOvf42id+++AMyZM4P8/Hxu3szj559PMXz4KKKjh5d7LXe+1wvY29sbfa+mJAmPBembtPRklJYQwhQUReHWzjnoslIs8vlWnq2w7///KpX05OTkEBPzX8aPn0DnzlFkZ2cxa9brrFixhClTpgGg1WrZtGkdr78+m+LiYv773/8wYsQz9Os3gFWrNvLll1+wevV7REV1x9e3JR9/vJWVK99l/PgJhIV1IinpFAsXvs2NGzd4+eVXuHXrJmPGjMLbuxFz576DRmPDunWrGD/+OTZs+JBHHvkbeXl5LF36Djt27MXFxZVjx46QmXmZn346wfz5SygqKmTWrOnMnTuL5ctXoygK//3vS9jY2PH224txcnJi797dvPDCaN5/fz1+fv7s37+XhQvf5uWXX6Vjx3C+++4bVq1aQcOGnmXG6PPPtzNt2ixatmyJh0d9duyI4/33lzNx4iTatGnHuXNnWLRoHleuZDNu3MtERnYhIeFHQ8KTmHgYlUrF0aOJ+Pu3pbi4mISEH5k+fRa//ZbNxInjGTTon0yaFENRURFbtmxk7txZhIV1wt3dA4D/+7+vGDfuJSZMmIStrW2513L399q1a1cuX86853s1FUl4LMjL3QGVCvQ1pFLDI4QwFRW1a46v337LorCwEE9PL7y8vPHy8ubttxei1WqNjnv22ecNtRMdOoSRlHSKceNeQqVSMWzYCDZsWENqagotWviyefNGBg58ioEDnwSgSZOm3LhxgxUrljB69Fj2799LTk4Oa9Z8gJubGwAzZszmqaf+QVzcx4wb9zJOTk4AeHjUN5TB2tqa6dNn4ehYsm/AgIGsWrUCgCNHEjh16id27z6Ai4srAGPH/puffjrBJ598REzMDGJjt/Hoo70M5Ro6dAQ///wT586dLTNGrVr50atXH8PrjRvXMmLEaB59tDcAjRv7cPPmTd55521Gj36eqKhuzJo1ncLCQtRqNceOHSUqqjtHjybyzDP/4vjxo+h0WsLCwrly5QqjR49lyJBhhkR12LCR7N27+4/asZKEx9nZhWee+ZehDOVdy93fq7d3Ixo08Cr1ezUFSXgsyEZjRYN69mRfzwekhkcIYRoqlQr7/v+vVjVptWrVmkcf7c3kyRPw8KhPWFgnOnfuSrduDxsd5+PTxPC7vb093t6NDJ9la2sHQFFRETk517l27SqBgcFG7w8JCaW4uJi0tIucP59C06ZNDcmO/hxt27bj/Pnz9y2ru7uHIdmBkiSgoKAAgLNnT6MoCoMG9TN6T2FhoeGY1NQUQ5Ki1759YLkJj49PU8Pv169fJzs7i5Url7N69XuG7TqdjsLCAi5fvkRYWAQ6nY6ffjqBlZUVDg72DBgwkGnTplBcXEx8/EHCwiKwtbWjcWMf+vbtzyeffERqagoZGemkpJwDMEpO7o5/Ra7l7u+1fv36dOxY+vdqCpLwWFgjD8c7CY/U8AghTESlUoHG1tLFqJQZM+YwatRzHDr0PxISDjNr1jQCA4NZsuTOA93a2vgxdr/E6n6djXU65a7z3O8YHdbWVvctp1p9//E/Op0OR0dH1q7dfM8+jUb/b74KRdEZ7fvzdZXG1vbO96l//0svTaBjx073HOvp6YVGoyEkpCM//ngIjUZDaGgYQUEhFBcXcfp0Ev/730GGDRsJwIULqYwb9yytW/sTFtaJ7t17UK+eG889N/y+Zajotei/1x9/jOfw4UOlfq+mIKO0LEy/xASAs70MSxdCCICffz7F0qXv0LRpM5566hnmz1/C1KnTOXIkgevXr1X6fO7uHri7e3Dy5HGj7SdOHEOj0dC4sQ++vq345ZdfjM5fUFDA6dPJNGvWArh/QnU/LVq05ObNmxQVFeHj08Tws2XLRg4e/BYoaZo6efKE0ftOn06u1Oe4ublTr54bly79avQ5Z84ks3r1CkPC16VLVxISDnH0aCIdOoRhb29Pu3YB7NgRx6VLv9K5c1cAduz4FHd3dxYvXkF09HAiI6O4evVqueUo71ru/l6ffjq62t9rZZg04Zk+fTpTpkwx2tazZ09at25d6k9CQgIAWVlZpe6Pi4sznCc5OZmhQ4cSHBxMz5492bRpkykvxWT0I7U01mpsNJJ/CiEEgKOjI3Fxn7BixVIyMtJJTU3hq6++xMenKa6u9ap0ziFDhhEX9zGffRZLRkY6X365l3XrVtG//xM4OTnxt7/1wdXVlWnTppCc/DMpKeeYOfM18vPzGTBgIFDSbAYlD/GCgtvlfmanTpG0auXH669P5ejRRDIy0lm2bCF79uwyJFFDh47gu+++YevWTaSn/0Js7Ef83/99ValrU6lUREcPJzZ2G59+uo1ff83g22+/YcGCudja2mFjU/IHdZcuXUlJOUdS0ik6dgwHSvo+7du3h/btA6lXrx4ADRt6kp2dRXz8D2RmXubbb7/mnXfmAiXNcfdT3rXc/b2mp/9SI99rRZmkSUun07F48WK2bdvGE088YbQvNjbWqP2vsLCQUaNG4eXlRUhICACnT5/G1taWAwcOGGXTzs7OQElb5ciRI+nZsydvvPEGx48f54033sDR0ZFBgwaZ4pJMpqlnyTW5u9jJwqFCCPGHZs2aM2fOfNavX81nn32CWq0mNDSMd95ZWmYTUlmGDBmKjY2Gbdu2smTJAho29CQ6ejjPPDMMACcnJ957bzWLFy/k5ZfHARAYGMR7762lUaPGAISGhtG2bXteeGEU06bNKvczraysWLRoBStWLGH69Cnk5+fTrFkL5syZT4cOYQB07hzF66/PZt26VaxZs5J27QJ4+umh7N+/t9LXZ2trS2zsRyxbtgh3dw/693+C0aPHGo7x9PTC17ek1snLyxuAjh3DWbv2faKiuhuOGzz4adLSLjJr1nSKiopo0qQJY8aMY926VZw+nUREROdSy1DetZjie60olVLDsyidP3+emJgY0tLSsLOzo1OnTsydO/e+x7/99tts376d3bt34+7uDsDq1avZtWsXO3fuLPU977//Pps3b+abb74xtA0uXLiQffv2sW/fviqVW6vVce3azSq9tyzW1mrc3By5fv0mxcW6Uo/5MTkLTzcHHvJyrvHP/yupSKxFzZBYm09lY11UVMjVq5fx8PBGo5Fm8sqytlbLPW0mFY11Wfe0u7sjVlYVS5RqPJ06dOgQvr6+fP755/j4+JR5bEpKCps2bWLKlCmGZAfgzJkz+Pr63vd9iYmJhIeHG3WEioiI4OLFi1y5cqX6F2Fm4W08JdkRQgghTKjGm7Sio6MrfOzSpUvx8/NjwIABRtvPnj2Lm5sb0dHRXLhwgYceeogXXniBbt26AZCZmYmfn5/Rexo2bAjA5cuXqV+/PlVhbV3z1Wn6zLOiGaioOom1+UiszaeysdbppGm8qvS9Cu6eH02YRlVibWWlqtZzulIJT0ZGBo888sh998fHxxvV1JQlPT2d/fv3s2TJEqPtxcXFpKam0rJlS6ZMmYKTkxO7d+9mzJgxrF+/nsjISG7fvm3ogKWnHxqnn9egstRqFW5ujuUfWEUuLvYmO7cwJrE2H4m1+VQ01rdvW3HlirraD4e/MknkzacisdbpVKjValxdHbCzs6vyZ1Uq4fH09GTPnj333e/q6lrhc+3cuRMPDw8effRR4wJZW3P48GGsrKwMF9a+fXvOnTvH2rVriYyMxM7O7p5e4vpEx8HBeH2qitLpFHJzb1XpvWWxslLj4mJPbm4+Wq20C5uSxNp8JNbmU9lYFxYWoNPp0GoV6YtSSSpVSby1Wp3U8JhYZWKt1SrodDpu3LhFfr7xjMwuLvYVTlArlfBoNJoy+9ZUxoEDB3jsscdK7ZXt6HhvTUurVq04ePAgAF5eXmRnZxvt17/29Cx77ZGymPIfB61WJ//4mInE2nwk1uZT0VhrtfKkrir9g1eSHdOrSqyrm8RbpN4uLy+P5ORkOne+d1jbuXPnCA0N5fDhw0bbT506RcuWLQEICwvjyJEjRsPbDx06RPPmzfHw8DBt4YUQohao4QG4QlhMTd3LFkl4Tp8uWVvE39//nn2+vr60aNGCmTNnkpiYyPnz53nrrbc4fvw4L7zwAgCDBg0iLy+PmJgYUlJSiIuLY8OGDYwdO/ae8wkhxF+JlVXJEgiFhVXrzyjEg0Z/L1tZVW+clUXW0tI3P+lndLybWq1m5cqVvPPOO/znP/8hNzeXtm3bsn79esPILA8PD9asWcOcOXN44oknaNCgAZMmTbpnkkMhhPirUautsLd3Ii/vOgA2NrYyqWkl6HQqaRY0k/JirSgKhYUF5OVdx97eqdoTE9b4xIO1lSUnHhQ1Q2JtPhJr86lKrBVFITf3Gvn5eSYuXd2jVqvR6eSeNoeKxtre3gkXF/dSE/fKTDwoq6ULIUQdo1KpcHX1wNnZDa222NLFqTWsrFS4ujpw48YtqeUxsYrG2srKusaWnJCERwgh6ii1Wo1aLctLVJS1tRo7Ozvy87VSc2liloi1zK4khBBCiDpPEh4hhBBC1HmS8AghhBCizpNRWn9QFAWdzjSh0E+fLUxPYm0+EmvzkVibj8TafGoi1mq1qsLTLkjCI4QQQog6T5q0hBBCCFHnScIjhBBCiDpPEh4hhBBC1HmS8AghhBCizpOERwghhBB1niQ8QgghhKjzJOERQgghRJ0nCY8QQggh6jxJeIQQQghR50nCI4QQQog6TxIeIYQQQtR5kvAIIYQQos6ThEcIIYQQdZ4kPCai0+lYunQpXbt2JTg4mOeee4709HRLF6tOyMnJYfr06XTr1o3Q0FCGDBlCYmKiYX98fDwDBw4kKCiIPn36sHv3bguWtu64cOECISEhxMXFGbYlJyczdOhQgoOD6dmzJ5s2bbJgCWu/7du307dvXwICAnjsscf44osvDPsyMjIYO3YsoaGhREVFsXjxYrRarQVLW3sVFxezZMkSevToQUhICNHR0Rw/ftywX+7rmvH+++8zbNgwo23lxdakz05FmMSyZcuUTp06Kd98842SnJysjBo1SunVq5dSUFBg6aLVeiNHjlT69eunJCQkKKmpqcobb7yhBAYGKufPn1dSUlKUgIAAZeHChUpKSoqyZs0apW3btsr//vc/Sxe7VissLFQGDhyo+Pn5KZ9++qmiKIpy7do1pVOnTsrUqVOVlJQUJTY2VgkICFBiY2MtXNraafv27Urbtm2VzZs3K2lpacqKFSsUf39/5ejRo0phYaHSq1cvZcyYMcqZM2eU/fv3K+Hh4cqSJUssXexaaenSpUqXLl2U77//Xrl48aISExOjdOjQQcnKypL7uoZs3rxZ8ff3V4YOHWrYVpHYmvLZKQmPCRQUFCghISHKli1bDNtu3LihBAYGKrt27bJgyWq/ixcvKn5+fkpiYqJhm06nUx599FFl8eLFyrRp05TBgwcbvWfixInKqFGjzF3UOuWdd95R/vWvfxklPCtXrlSioqKUoqIio+N69eplqWLWWjqdTunRo4cyd+5co+2jRo1SVq5cqezatUtp3769kpOTY9j30UcfKaGhofJHVBX0799feeuttwyvf//9d8XPz0/Zt2+f3NfVlJmZqYwdO1YJDg5W+vTpY5TwlBdbUz87pUnLBE6fPs3NmzeJjIw0bHNxcaFt27YkJCRYsGS1n5ubG6tWrSIgIMCwTaVSoVKpyM3NJTEx0SjuABERERw5cgRFUcxd3DohISGBbdu2MXfuXKPtiYmJhIeHY21tbdgWERHBxYsXuXLlirmLWatduHCBX3/9lccff9xo+9q1axk7diyJiYm0a9cOV1dXw76IiAjy8vJITk42d3FrPQ8PD7755hsyMjLQarVs27YNGxsb/P395b6upp9//hmNRsPOnTsJCgoy2ldebE397JSExwQyMzMB8Pb2NtresGFDwz5RNS4uLnTv3h0bGxvDtn379pGWlkbXrl3JzMzEy8vL6D0NGzYkPz+f69evm7u4tV5ubi6TJk3itddeu+d+vl+sAS5fvmy2MtYFFy5cAODWrVuMHj2ayMhInnzySb7++mtAYl3TYmJi0Gg0PPLIIwQEBLBo0SKWLl1K06ZNJdbV1LNnT5YtW0aTJk3u2VdebE397JSExwTy8/MBjB7KALa2thQUFFiiSHXW0aNHmTp1Kr169eLhhx/m9u3b98Rd/7qwsNASRazVZsyYQUhIyD01D0Cpsba1tQWQ+7yS8vLyAJg8eTL9+vVj3bp1dOnShXHjxhEfHy+xrmEpKSk4OzuzfPlytm3bxsCBA3n11VdJTk6WWJtQebE19bPTuvxDRGXZ2dkBJQ9Y/e9Q8oXa29tbqlh1zoEDB3j11VcJDQ1lwYIFQMn/GH9ObPSvJfaVs337dhITE9m1a1ep++3s7O6Jtf4fJQcHB5OXry7RaDQAjB49mieeeAKANm3akJSUxPr16yXWNejy5cu88sorbNiwgY4dOwIQEBBASkoKy5Ytk1ibUHmxNfWzU2p4TEBfHZednW20PTs7G09PT0sUqc7ZvHkzL774Ij169GDlypWGvxK8vb1LjbuDgwPOzs6WKGqt9emnn3L16lUefvhhQkJCCAkJAeD111/n2WefxcvLq9RYA3KfV5I+Xn5+fkbbW7ZsSUZGhsS6Bp04cYKioiKjfoAAQUFBpKWlSaxNqLzYmvrZKQmPCfj7++Pk5MThw4cN23Jzc0lKSiIsLMyCJasbtm7dyqxZs4iOjmbhwoVG1Z8dO3bkxx9/NDr+0KFDhIaGolbL7V4ZCxYsYM+ePWzfvt3wA/DSSy8xZ84cwsLCOHLkiNFcMIcOHaJ58+Z4eHhYqNS1U7t27XB0dOTEiRNG28+ePUvTpk0JCwsjKSnJ0PQFJbF2dHTE39/f3MWt1fR9SM6cOWO0/ezZszRr1kzuaxMqL7Ymf3ZWe5yXKNXChQuV8PBw5cCBA0ZzCRQWFlq6aLVaamqq0q5dO+Xf//63kp2dbfSTm5urnD17VmnXrp0yf/58JSUlRVm7dq3Mw1OD7h6WfuXKFSUsLEyZPHmycu7cOeXTTz9VAgIClLi4OAuXsnZavny5EhISouzatctoHp5Dhw4pt2/fVh599FFl9OjRSnJysmEenmXLllm62LWOVqtVhgwZovTp00eJj49XLly4oCxatEhp06aNcvz4cbmva9DkyZONhqVXJLamfHZKwmMixcXFyrx585SIiAglODhYee6555T09HRLF6vWe++99xQ/P79SfyZPnqwoiqJ8++23Sr9+/ZT27dsrffr0UXbv3m3hUtcddyc8iqIoJ06cUJ566imlffv2So8ePZQPPvjAgqWr/datW6f07NlTadeundK/f39l//79hn0XL15URo4cqQQEBChRUVHK4sWLFa1Wa8HS1l45OTnKjBkzlIcfflgJCQlR/vnPfyqHDx827Jf7umb8OeFRlPJja8pnp0pRZHISIYQQQtRt0qlBCCGEEHWeJDxCCCGEqPMk4RFCCCFEnScJjxBCCCHqPEl4hBBCCFHnScIjhBBCiDpPEh4hhBBC1HmS8AghhBCizpOERwhhcZmZmURHRxMQEEBkZCT5+fmWLpIQoo6xtnQBhBBi48aNHD9+nPnz5+Pp6Ym9vb2liySEqGMk4RFCWFxOTg4NGzakb9++li6KEKKOkiYtIYRF9ezZk7i4OC5dukTr1q0ZNmwYrVu35qOPPqJHjx6Ehobyww8/APDJJ58wcOBAgoODCQwMZMCAAXzxxReGc8XFxREQEEBiYiKDBg0iICCA3r178/XXX5Oamsrw4cMJCgrib3/7G7t37zYqx6VLl5g4cSLh4eEEBQUxfPhwkpKSjI75/PPP6d+/P4GBgURERPDqq6+SlZVl+iAJIapNFg8VQlhUUlISixcvJikpiXfffZe0tDQmTZpEgwYNeO2117h9+za9evXis88+Y/bs2bz44ot06NCBGzdusHr1apKSkvjqq6/w8vIiLi6OmJgYGjZsyPjx4/H29mbBggX88ssv1K9fnyFDhuDv78+7777LiRMnOHDgAF5eXly7do1//OMf2NvbM378eOzt7dm4cSOnTp0iNjYWX19fjhw5wrBhwxg3bhxhYWFkZmYyf/58mjVrxubNmy0dRiFEOaRJSwhhUW3btsXd3R0bGxuCg4MpKCgA4JlnnqFPnz6G49LT0xk9ejTjxo0zbGvcuDEDBw7kyJEjPPbYYwDodDqef/55nnzySQByc3OZMGECw4cPZ+TIkQA4OzszaNAgTp06hZeXFxs3biQnJ4cPP/yQxo0bA9CtWzf69u3LkiVLWLp0KUeOHMHOzo4xY8ZgY2MDQL169fjpp59QFAWVSmX6YAkhqkwSHiHEA6lNmzZGr6dMmQKUJDCpqamkpaVx+PBhAAoLC42ODQkJMfzu4eEBQFBQkGFbvXr1DOcCiI+Pp02bNnh6elJcXAyAWq2mW7du7Ny5E4CwsDAWLVpEv3796N27N927dycqKoru3bvX1CULIUxIEh4hxAPJwcHB6PUvv/zC9OnTiY+PR6PR0KJFC/z9/QH4c8u8k5PTPecra+RXTk4OaWlptGvXrtT9+fn5hISEsGrVKjZs2MD69etZtWoV9evX5/nnn2fYsGGVvTwhhJlJwiOEeODpdDrGjBmDRqMhNjaWNm3aYG1tTUpKCjt27Kj2+Z2dnQkPD2fSpEml7tc3YXXt2pWuXbuSn5/PoUOH2LRpE7NnzyYoKIjAwMBql0MIYToySksI8cC7fv06Fy5cYPDgwQQEBGBtXfK32nfffQeUJETVER4ezoULF2jevDkBAQGGnx07dhAbG4uVlRVvv/02gwYNQlEU7O3t6dGjB5MnTwZKRngJIR5sUsMjhHjgeXh40LhxY7Zs2YKXlxcuLi58//33bNq0CaDaMzOPGDGCHTt2MGLECEaNGoWbmxt79uzh448/ZurUqQBERESwfv16pkyZQv/+/SkqKmLNmjXUq1ePiIiIal+jEMK0pIZHCFErrFixAk9PT6ZMmcJ//vMfTpw4wXvvvUeLFi1ITEys1rk9PT356KOPaNy4MTNmzOD555/n5MmTzJkzhxEjRgDQvXt3FixYwLlz5xg/fjwTJ07E3t6eTZs2GTpBCyEeXDIPjxBCCCHqPKnhEUIIIUSdJwmPEEIIIeo8SXiEEEIIUedJwiOEEEKIOk8SHiGEEELUeZLwCCGEEKLOk4RHCCGEEHWeJDxCCCGEqPMk4RFCCCFEnScJjxBCCCHqPEl4hBBCCFHn/X/yFdWNWjSXkAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg)\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.13 ('easyrl')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "8994a120d39b6e6a2ecc94b4007f5314b68aa69fc88a7f00edf21be39b41f49c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
